# Technical Documentation: agent-infra/sandbox

> ℹ️ **Provenance:** Multi-Tier Ingestion · [CodeWiki Reference](https://codewiki.google/github.com/agent-infra/sandbox)

### Overview (`README.md`)

# AIO Sandbox - All-in-One Agent Sandbox Environment

<p align="center">
  <img src="./website/docs/public/aio-icon.png" alt="logo" width="200"/>
</p>

<p align="center">
  <strong>🌐 Browser | 💻 Terminal | 📁 File | 🔧 VSCode | 📊 Jupyter | 🤖 MCP</strong>
</p>

<div align="center">
<p>
        🌐 <a href="https://sandbox.agent-infra.com/">Website</a>&nbsp&nbsp
        | &nbsp&nbsp🔌 <a href="https://sandbox.agent-infra.com/api">API</a>&nbsp&nbsp
        | &nbsp&nbsp📑 <a href="https://arxiv.org/pdf/2509.02544#S2.SS2">Paper</a>&nbsp&nbsp
        | &nbsp&nbsp🌟 <a href="https://github.com/agent-infra/sandbox/tree/main/examples">Examples</a>&nbsp&nbsp
        | &nbsp&nbsp📊 <a href="https://github.com/agent-infra/sandbox/tree/main/evaluation">Evaluation</a> &nbsp&nbsp
</p>
</div>

<p align="center">
  <a href="https://github.com/agent-infra/sandbox/releases"><img src="https://img.shields.io/github/v/release/agent-infra/sandbox" alt="Release"></a>
  <a href="https://github.com/agent-infra/sandbox/blob/main/LICENSE"><img src="https://img.shields.io/github/license/agent-infra/sandbox" alt="License"></a>
  <a href="https://pypi.org/project/agent-sandbox/"><img src="https://img.shields.io/pypi/v/agent-sandbox" alt="PyPI"></a>
  <a href="https://www.npmjs.com/package/@agent-infra/sandbox"><img src="https://img.shields.io/npm/v/@agent-infra/sandbox" alt="npm"></a>
</p>



## 🚀 Quick Start

Get up and running in 30 seconds:

```bash
# Recommended: Enable API Key authentication (protects all services: API, JupyterLab, VNC)
# - Supports three methods: X-AIO-API-Key header, Authorization: Bearer header, ?api_key= query parameter
# - Without SANDBOX_API_KEY, services remain open (backward compatible)
docker run --security-opt seccomp=unconfined --rm -it \
  -e SANDBOX_API_KEY=your-secret-key \
  -p 127.0.0.1:8080:8080 ghcr.io/agent-infra/sandbox:latest
```

For users in mainland China:

```bash
docker run --security-opt seccomp=unconfined --rm -it \
  -e SANDBOX_API_KEY=your-secret-key \
  -p 127.0.0.1:8080:8080 enterprise-public-cn-beijing.cr.volces.com/vefaas-public/all-in-one-sandbox:1.11.0
```

For reproducible deployments, pin a release tag. Replace `1.11.0` with the release you want:

```bash
docker run --security-opt seccomp=unconfined --rm -it \
  -p 127.0.0.1:8080:8080 ghcr.io/agent-infra/sandbox:1.11.0
# or use the pinned mainland China mirror
docker run --security-opt seccomp=unconfined --rm -it \
  -p 127.0.0.1:8080:8080 enterprise-public-cn-beijing.cr.volces.com/vefaas-public/all-in-one-sandbox:1.11.0
```

These examples intentionally bind the host side to `127.0.0.1` because the sandbox listens on `0.0.0.0` inside the container. For cloud deployment, keep port `8080` private and publish it through a reverse proxy or Ingress: [Cloud Deployment Guide](https://sandbox.agent-infra.com/guide/start/cloud-deployment).

Once running, access the environment at:
- 📖 **Documentation**: http://localhost:8080/v1/docs
- 🌐 **VNC Browser**: http://localhost:8080/vnc/index.html?autoconnect=true
- 💻 **VSCode Server**: http://localhost:8080/code-server/
- 🤖 **MCP Services**: http://localhost:8080/mcp

## 🎯 What is AIO Sandbox?

AIO Sandbox is an **all-in-one** agent sandbox environment that combines Browser, Shell, File, MCP operations, and VSCode Server in a single Docker container. Built on cloud-native lightweight sandbox technology, it provides a unified, secure execution environment for AI agents and developers.

<p align="center">
  <img src="website/docs/public/images/aio-sandbox.png" alt="AIO Sandbox Architecture" width="600"/>
</p>

### Why Choose AIO Sandbox?

Traditional sandboxes are **single-purpose** (browser, code, or shell), making file sharing and functional coordination extremely challenging. AIO Sandbox solves this by providing:

- ✅ **Unified File System** - Files downloaded in browser are instantly available in Shell/File operations
- ✅ **Multiple Interfaces** - VNC, VSCode, Jupyter, and Terminal in one unified environment
- ✅ **Secure Execution** - Sandboxed Python and Node.js execution with safety guarantees
- ✅ **Zero Configuration** - Pre-configured MCP servers and development tools ready to use
- ✅ **Agent-Ready** - MCP-compatible APIs for seamless AI agent integration

## 📦 Installation

### SDK Installation

<table>
<tr>
<td>

**Python**
```bash
pip install agent-sandbox
```

</td>
<td>

**TypeScript/JavaScript**
```bash
npm install @agent-infra/sandbox
```

</td>
<td>

**Golang**
```bash
go get github.com/agent-infra/sandbox-sdk-go
```

</td>
</tr>
</table>

### Basic Usage

<table>
<tr>
<td>

**Python Example**
```python
from agent_sandbox import Sandbox

# Initialize client
client = Sandbox(base_url="http://localhost:8080")
home_dir = client.sandbox.get_context().home_dir

# Execute shell commands
result = client.shell.exec_command(command="ls -la")
print(result.data.output)

# File operations
content = client.file.read_file(file=f"{home_dir}/.bashrc")
print(content.data.content)

# Browser automation
screenshot = client.browser.screenshot()
```

</td>
<td>

**TypeScript Example**
```typescript
import { Sandbox } from '@agent-infra/sandbox';

// Initialize client
const sandbox = new Sandbox({ baseURL: 'http://localhost:8080' });

// Execute shell commands
const result = await sandbox.shell.exec({ command: 'ls -la' });
console.log(result.output);

// File operations
const content = await sandbox.file.read({ path: '/home/gem/.bashrc' });
console.log(content);

// Browser automation
const screenshot = await sandbox.browser.screenshot();
```

</td>
</tr>
</table>

## 🌟 Key Features

### 🔗 Unified Environment
All components run in the same container with a shared filesystem, enabling seamless workflows:

<p align="center">
  <img src="website/docs/public/images/aio-index.png" alt="Unified Environment" width="600"/>
</p>

### 🌐 Browser Automation
Full browser control through multiple interfaces:
- **VNC** - Visual browser interaction through remote desktop
- **CDP** - Chrome DevTools Protocol for programmatic control
- **MCP** - High-level browser automation tools

<p align="center">
  <img src="website/docs/public/images/browser.png" alt="Browser Automation" width="600"/>
</p>

### 💻 Development Tools
Integrated development environment with:
- **VSCode Server** - Full IDE experience in browser
- **Jupyter Notebook** - Interactive Python environment
- **Terminal** - WebSocket-based terminal access
- **Port Forwarding** - Smart preview for web applications

<p align="center">
  <img src="website/docs/public/images/code-server.png" alt="VSCode Server" width="600"/>
</p>

### 🤖 MCP Integration
Pre-configured Model Context Protocol servers:
- **Browser** - Web automation and scraping
- **File** - File system operations
- **Shell** - Command execution
- **Markitdown** - Document processing

<p align="center">
  <img src="website/docs/public/images/mcp.png" alt="MCP Integration" width="600"/>
</p>

## 📚 Complete Example

Convert a webpage to Markdown with embedded screenshot:

```python
import asyncio
import base64
from playwright.async_api import async_playwright
from agent_sandbox import Sandbox

async def site_to_markdown():
    # Initialize sandbox client
    c = Sandbox(base_url="http://localhost:8080")
    home_dir = c.sandbox.get_context().home_dir

    # Browser: Automation to download HTML
    async with async_playwright() as p:
        browser_info = c.browser.get_info().data
        page = await (await p.chromium.connect_over_cdp(browser_info.cdp_url)).new_page()
        await page.goto("https://example.com", wait_until="networkidle")
        html = await page.content()
        screenshot_b64 = base64.b64encode(await page.screenshot()).decode('utf-8')

    # Jupyter: Convert HTML to markdown in sandbox
    c.jupyter.execute_code(code=f"""
from markdownify import markdownify
html = '''{html}'''
screenshot_b64 = "{screenshot_b64}"

md = f"{{markdownify(html)}}\\n\\n"
with open('{home_dir}/site.md', 'w') as f:
    f.write(md)
print("Done!")
""")

    # Shell: List files in sandbox
    list_result = c.shell.exec_command(command=f"ls -lh {home_dir}")
    print(f"Files in sandbox: {list_result.data.output}")

    # File: Read the generated markdown
    return c.file.read_file(file=f"{home_dir}/site.md").data.content

if __name__ == "__main__":
    result = asyncio.run(site_to_markdown())
    print(f"Markdown saved successfully!")
```

<p align="center">
  <img src="website/docs/public/images/example.png" alt="Example Output" width="600"/>
</p>

## 🏗️ Architecture

```
┌─────────────────────────────────────────────────────────────┐
│                    🌐 Browser + VNC                        │
├─────────────────────────────────────────────────────────────┤
│  💻 VSCode Server  │  🐚 Shell Terminal  │  📁 File Ops   │
├─────────────────────────────────────────────────────────────┤
│              🔗 MCP Hub + 🔒 Sandbox Fusion               │
├─────────────────────────────────────────────────────────────┤
│         🚀 Preview Proxy + 📊 Service Monitoring          │
└─────────────────────────────────────────────────────────────┘
```

## 🛠️ API Reference

### Core APIs

| Endpoint | Description |
|----------|-------------|
| `/v1/sandbox` | Get sandbox environment information |
| `/v1/shell/exec` | Execute shell commands |
| `/v1/file/read` | Read file contents |
| `/v1/file/write` | Write file contents |
| `/v1/browser/screenshot` | Take browser screenshot |
| `/v1/jupyter/execute` | Execute Jupyter code |

### MCP Servers

| Server | Tools Available |
|--------|----------------|
| `browser` | `navigate`, `screenshot`, `click`, `type`, `scroll` |
| `file` | `read`, `write`, `list`, `search`, `replace` |
| `shell` | `exec`, `create_session`, `kill` |
| `markitdown` | `convert`, `extract_text`, `extract_images` |

## 🚢 Deployment

### Docker Compose

```yaml
services:
  sandbox:
    container_name: aio-sandbox
    image: ghcr.io/agent-infra/sandbox:latest
    security_opt:
      - seccomp:unconfined
    ports:
      - "127.0.0.1:${HOST_PORT:-8080}:8080"
    volumes:
      - sandbox_data:/home/gem/workspace
    extra_hosts:
      - "host.docker.internal:host-gateway"
    restart: "unless-stopped"
    shm_size: "2gb"
    environment:
      SANDBOX_API_KEY: ${SANDBOX_API_KEY:-}
      PROXY_SERVER: ${PROXY_SERVER:-}
      WORKSPACE: ${WORKSPACE:-/home/gem/workspace}
      TZ: ${TZ:-Asia/Singapore}

volumes:
  sandbox_data:
```

### Kubernetes

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: aio-sandbox
spec:
  replicas: 2
  selector:
    matchLabels:
      app: aio-sandbox
  template:
    metadata:
      labels:
        app: aio-sandbox
    spec:
      containers:
      - name: aio-sandbox
        image: ghcr.io/agent-infra/sandbox:latest
        ports:
        - containerPort: 8080
        resources:
          limits:
            memory: "2Gi"
            cpu: "1000m"
```

## 🤝 Integration Examples

### Browser Use Integration

```python
import asyncio

from agent_sandbox import Sandbox
from browser_use import Agent, Tools
from browser_use.browser import BrowserProfile, BrowserSession
from browser_use.llm import ChatOpenAI

sandbox = Sandbox(base_url="http://localhost:8080")
print("sandbox", sandbox.browser)
cdp_url = sandbox.browser.get_info().data.cdp_url

browser_session = BrowserSession(
    browser_profile=BrowserProfile(cdp_url=cdp_url, is_local=True)
)
tools = Tools()


async def main():
    agent = Agent(
        task='Visit https://duckduckgo.com and search for "browser-use founders"',
        llm=ChatOpenAI(model="gcp-claude4.1-opus"),
        tools=tools,
        browser_session=browser_session,
    )

    await agent.run()
    await browser_session.kill()

    input("Press Enter to close...")


if __name__ == "__main__":
    asyncio.run(main())
```

### LangChain Integration

```python
from langchain.tools import BaseTool
from agent_sandbox import Sandbox

class SandboxTool(BaseTool):
    name = "sandbox_execute"
    description = "Execute commands in AIO Sandbox"

    def _run(self, command: str) -> str:
        client = Sandbox(base_url="http://localhost:8080")
        result = client.shell.exec_command(command=command)
        return result.data.output
```

### OpenAI Assistant Integration

```python
from openai import OpenAI
from agent_sandbox import Sandbox
import json

client = OpenAI(
    api_key="your_api_key",
)
sandbox = Sandbox(base_url="http://localhost:8080")


# define a tool to run code in the sandbox
def run_code(code, lang="python"):
    if lang == "python":
        return sandbox.jupyter.execute_code(code=code).data
    return sandbox.nodejs.execute_nodejs_code(code=code).data


# Use OpenAI
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "calculate 1+1"}],
    tools=[
        {
            "type": "function",
            "function": {
                "name": "run_code",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "code": {"type": "string"},
                        "lang": {"type": "string"},
                    },
                },
            },
        }
    ],
)


if response.choices[0].message.tool_calls:
    args = json.loads(response.choices[0].message.tool_calls[0].function.arguments)
    print("args", args)
    result = run_code(**args)
    print(result['outputs'][0]['text'])
```

### MiniMax Integration

MiniMax provides an OpenAI-compatible API, so you can use the same `openai` SDK with a different `base_url`:

```python
from openai import OpenAI
from agent_sandbox import Sandbox
import json

client = OpenAI(
    api_key="your_minimax_api_key",
    base_url="https://api.minimax.io/v1",
)
sandbox = Sandbox(base_url="http://localhost:8080")


def run_code(code, lang="python"):
    if lang == "python":
        return sandbox.jupyter.execute_code(code=code).data
    return sandbox.nodejs.execute_code(code=code).data


response = client.chat.completions.create(
    model="MiniMax-M2.7",
    messages=[{"role": "user", "content": "calculate 1+1"}],
    tools=[
        {
            "type": "function",
            "function": {
                "name": "run_code",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "code": {"type": "string"},
                        "lang": {"type": "string"},
                    },
                },
            },
        }
    ],
    temperature=0.01,  # MiniMax requires temperature > 0
)


if response.choices[0].message.tool_calls:
    args = json.loads(response.choices[0].message.tool_calls[0].function.arguments)
    result = run_code(**args)
    print(result.outputs[0].text)
```

See the full [minimax-integration example](examples/minimax-integration) for more details.

## 🤝 Contributing

We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.

## 📄 License

AIO Sandbox is released under the [Apache License 2.0](LICENSE).

## 🙏 Acknowledgments

Built with ❤️ by the Agent Infra team. Special thanks to all contributors and the open-source community.

## 📞 Support

- 📖 [Documentation](https://sandbox.agent-infra.com)
- 💬 [GitHub Discussions](https://github.com/agent-infra/sandbox/discussions)
- 🐛 [Issue Tracker](https://github.com/agent-infra/sandbox/issues)

---

<p align="center">
  <strong>Ready to revolutionize your AI development workflow?</strong><br/>
  <a href="https://github.com/agent-infra/sandbox">⭐ Star us on GitHub</a> •
  <a href="https://sandbox.agent-infra.com">📚 Read the Docs</a> •
  <a href="https://github.com/agent-infra/sandbox/issues">🐛 Report Issues</a>
</p>

---

### Overview (`evaluation/README.md`)

# AIO Sandbox Tool Evaluation

English | [简体中文](./README_zh.md)

> A comprehensive evaluation framework for MCP (Model Context Protocol) tools and AI agent capabilities based on aio-sandbox.

Inspired by [Anthropic's "Writing Tools for Agents"](https://www.anthropic.com/engineering/writing-tools-for-agents)

## Prerequisites

- Python >= 3.13
- [uv](https://github.com/astral-sh/uv) package manager

## Installation

1. **Clone the repository**:
   ```bash
   git clone <repository-url>
   cd evaluation
   ```

2. **Install dependencies**:
   ```bash
   uv sync
   ```

3. **Configure environment**:
   ```bash
   cp .env.example .env
   ```

   Edit `.env` with your credentials:
   ```env
   # Azure OpenAI Configuration
   OPENAI_BASE_URL=https://your-endpoint.openai.azure.com
   OPENAI_API_KEY=your-api-key
   AZURE_OPENAI_DEPLOYMENT=gpt-4
   AZURE_OPENAI_API_VERSION=2024-02-15-preview

   # MCP Server Configuration
   MCP_SERVER_URL=http://localhost:8080/mcp

   # Optional: Concurrency
   MAX_CONCURRENT_TASKS=5
   ```

## Usage

### Run All Evaluations

```bash
uv run main.py
```

### Run Specific Evaluation

```bash
uv run main.py --eval basic
uv run main.py --eval browser
uv run main.py --eval collaboration
uv run main.py --eval workflow
```

### Use OpenAI-Compatible Providers

The evaluation framework also supports standard OpenAI and compatible APIs
(e.g. [MiniMax](https://www.minimaxi.com/)) via the `--agent openai` flag:

```bash
# Standard OpenAI
uv run main.py --agent openai --openai-model gpt-4

# MiniMax (OpenAI-compatible)
export OPENAI_API_KEY="your_minimax_api_key"
uv run main.py --agent openai \
    --openai-base-url https://api.minimax.io/v1 \
    --openai-model MiniMax-M2.7
```

### Available Categories

| Category | Description |
|----------|-------------|
| `ping` | Basic connectivity test |
| `basic` | Single tool capabilities (file ops, code execution, shell) |
| `browser` | Browser automation basics (navigation, DOM, forms) |
| `browser_advanced` | Advanced browser interactions (click, hover, keyboard) |
| `code_advanced` | Advanced code execution (async, error handling, data structures) |
| `collaboration` | Multi-tool workflows (file+code, browser+file) |
| `editor` | Text editor operations (view, create, replace, insert, undo) |
| `packages` | Package management (Python, Node.js) |
| `util` | Utilities (Markdown conversion) |
| `error` | Error handling tests |
| `workflow` | Real-world scenarios (code review, data pipeline, web scraping) |
| `nextjs` | Next.js project startup |

## Project Structure

```
evaluation/
├── main.py                 # Main entry point and orchestration
├── agent_loop.py           # Agent loop implementations (Azure OpenAI, OpenAI-compatible, etc.)
├── dataset_parser.py       # XML dataset parser
├── .env.example            # Environment configuration template
├── pyproject.toml          # Project dependencies
├── dataset/                # Evaluation datasets
│   ├── evaluation_basic.xml
│   ├── evaluation_browser.xml
│   ├── evaluation_collaboration.xml
│   └── ...
└── result/                 # Evaluation reports (auto-generated)
    └── YYYYMMDD/           # Date-based output directory
        └── evaluation_*.md
```

## Extending the Framework

### Add New Evaluation Category

1. Create XML file in `dataset/`:
   ```
   dataset/evaluation_mycategory.xml
   ```

2. Run:
   ```bash
   uv run main.py --eval mycategory
   ```

## Contributing

Contributions welcome! Please:

1. Fork the repository
2. Create a feature branch
3. Add tests for new features
4. Ensure all tests pass
5. Submit a Pull Request

## License

See [LICENSE](../LICENSE) in the repository root.

## References

- [Model Context Protocol (MCP)](https://modelcontextprotocol.io/)
- [Anthropic: Writing Tools for Agents](https://www.anthropic.com/engineering/writing-tools-for-agents)
- [Azure OpenAI Documentation](https://learn.microsoft.com/azure/ai-services/openai/)
- [MiniMax API Documentation](https://platform.minimaxi.com/document/introduction)

---

### Overview (`examples/README.md`)

# Agent Sandbox Examples

This directory contains examples demonstrating various use cases and integrations with agent-sandbox.

## Table of Contents

- [basic-file-operations](./basic-file-operations) - Core file operations (upload, read, list, download)
- [oss-upload](./oss-upload) - Stream sandbox files to cloud storage (Volcengine TOS, AWS S3)
- [volcengine-provider](./volcengine-provider) - Volcengine cloud provider integration
- [site-to-markdown](./site-to-markdown) - Website to markdown conversion with browser automation
- [browser-use-integration](./browser-use-integration) - AI-driven browser automation
- [playwright-integration](./playwright-integration) - Browser automation with Playwright
- [openai-integration](./openai-integration) - OpenAI function calling with code execution
- [ag2-integration](./ag2-integration) - AG2 multi-agent workflow with sandbox-backed code execution
- [minimax-integration](./minimax-integration) - MiniMax function calling with code execution (OpenAI-compatible)
- [langgraph-deepagents-integration](./langgraph-deepagents-integration) - LangGraph deep agent with MCP tools integration
- [code-execute](./code-execute) - Execute code in sandbox (Jupyter and Node.js)



## Prerequisites

All examples require:
- Python 3.12+
- A running sandbox instance (most examples use `http://localhost:8080`)
- uv package manager

## Contributing

We welcome contributions of new examples!

### Quick Start (Easiest Way)

Copy the `_template` directory and start coding:

```bash
# Copy template to your new example
cp -r _template my-example-name
cd my-example-name

# Set up environment
cp .env.example .env

# Start coding in main.py
# Run it: uv run main.py
```

The template includes all necessary files - just modify `main.py` with your code!


### Before Submitting

1. Test your example:
   ```bash
   uv run main.py
   ```

2. Update the main `examples/README.md` Table of Contents

3. Keep it focused - one clear purpose per example

### Example Naming

- Use kebab-case: `browser-automation`, `file-operations`
- For integrations: `openai-integration`, `langgraph-deepagents-integration`

### Need Help?

- Check existing examples for reference
- Review the [Agent Sandbox Documentation](https://sandbox.agent-infra.com)
- Open an issue for questions or suggestions

---

### Overview (`evaluation/dataset/README.md`)

Dataset 评测用例总览

  1. evaluation_ping.xml - 基础连通性测试

  - 测试 aio 系统版本获取:回答 aio 系统的版本号

  2. evaluation_basic.xml - 单工具基础能力测试

  A. 环境探测类

  - 检查 Python 包 'fastapi' 是否已安装
  - 统计已安装的 Python 包数量

  B. 文件操作类

  - 创建文件并写入内容 "Hello MCP",然后读取
  - 列出 /tmp 目录中以 'test_eval' 开头的文件数量
  - 搜索文件中 'Hello MCP' 模式的匹配次数

  C. 代码执行类

  - 执行 Python 代码计算 2^10
  - 计算 1-100 内所有偶数的和
  - 统计字符串 "Model Context Protocol" 中的元音字母数量

  D. Shell 操作类

  - 执行 bash echo 命令输出 "MCP_TEST"
  - 使用 bash 统计 /tmp 目录中的文件夹数量

  3. evaluation_browser.xml - 浏览器基础测试

  - 导航到 bytedance.com,检查是否包含 'ByteDance' 或 '字节跳动'
  - 导航到 bytedance.com,统计页面链接数量
  - 导航到 baidu.com,用 JavaScript 获取链接数量
  - 导航到 baidu.com,用 JavaScript 获取页面标题
  - 导航到 baidu.com,统计 DOM 中的 anchor 元素数量
  - 测试表单填充:在 baidu.com 搜索框填入 'test_search'
  - 测试表单填充工作流:填入 'MCP test' 并验证
  - 测试完整浏览器工作流:导航、读取链接、获取 markdown、执行 JS
  - 测试标签页管理:创建新标签页并统计数量
  - 测试标签页切换:切换标签页并获取标题
  - 搜索 "aio sandbox",导航到 GitHub 页面,输出主要贡献者
  - 获取浏览器下载列表并统计数量
  - 触发下载并检查下载列表是否包含文件
  - 检查下载项是否包含 'filename' 字段

  4. evaluation_browser_advanced.xml - 浏览器高级交互测试

  A. 元素点击操作

  - 点击按钮并验证文本变化
  - 点击多个按钮中的特定按钮(使用索引)

  B. 表单填充与提交

  - 填充文本输入框和邮箱输入框

  C. 键盘操作

  - 测试按键事件(Enter 键)
  - 测试特殊按键(Tab 键)
  - 测试组合键(Delete 键)

  D. 鼠标移动与悬停

  - 测试鼠标悬停事件
  - 测试悬停菜单显示
  - 测试悬停 tooltip 显示

  E. 滚动操作

  - 测试页面滚动
  - 测试负向滚动(向上滚动)
  - 测试滚动到底部

  F. 导航历史

  - 测试后退功能
  - 测试前进功能

  G. 标签页管理

  - 关闭标签页并统计剩余数量
  - 切换标签页后关闭
  - 测试关闭最后一个标签页的行为

  H. 下拉选择

  - 测试下拉菜单选择
  - 测试通过索引选择下拉选项

  I. 复杂交互场景

  - 测试计算器交互:填充数字并执行加法运算

  J. 可点击元素获取

  - 过滤特定类型的可点击元素
  - 获取复杂页面中的所有可交互元素

  K. 浏览器信息获取

  - 获取浏览器视口信息
  - 获取 CDP URL
  - 计算视口面积

  5. evaluation_code_advanced.xml - 代码执行高级测试

  A. JavaScript 基础执行

  - 基础算术运算
  - 字符串反转操作

  B. JavaScript 对象和数组

  - 数组求和操作
  - JSON 解析

  C. Python 高级特性

  - 列表推导式计算平方和
  - 字典值求和
  - lambda 和 map 函数使用

  D. 文件操作 + 代码执行

  - Python 文件 I/O 操作

  E. JavaScript 异步代码

  - 同步循环求和

  F. 错误处理

  - Python 异常捕获(ZeroDivisionError)
  - JavaScript 错误处理(JSON 解析错误)

  G. 数学运算

  - Python math 库使用
  - JavaScript Math 操作

  H. 字符串处理

  - Python 正则表达式匹配邮箱
  - JavaScript 正则表达式匹配数字

  I. 数据结构

  - Python 集合交集操作

  J. 综合场景

  - Python 数据处理管道
  - JavaScript 函数式编程

  6. evaluation_collaboration.xml - 多工具协作测试

  E. 文件+代码执行

  - 读取文件并统计 'async' 出现次数
  - 创建并执行斐波那契数列脚本

  F. Shell+文件操作

  - 创建目录和文件,然后读取
  - 获取当前工作目录并写入文件

  G. 环境探测+代码分析

  - 获取包列表并统计包含 'fast' 的包数量

  H. Browser + 文件操作

  - 创建 HTML 文件并用浏览器导航验证

  I. 编辑器 + 代码执行

  - 使用编辑器创建 Python 文件并执行
  - 修改文件后重新执行

  J. 复杂多步协作

  - bash + 文件 + 代码执行管道
  - 获取上下文并写入文件验证版本号

  K. 浏览器 + 代码分析

  - 浏览器 evaluate + Python 处理 DOM 数据

  L. 文件查找 + 处理

  - 批量处理文件
  - 文件搜索和聚合统计

  7. evaluation_editor.xml - str_replace_editor 工具测试

  A. 文件查看 (view)

  - 查看完整文件内容
  - 查看指定行范围

  B. 文件创建 (create)

  - 创建新的 Python 文件

  C. 字符串替换 (str_replace)

  - 单次字符串替换
  - 多行字符串替换

  D. 插入 (insert)

  - 在指定行插入内容

  E. 复杂编辑场景

  - Python 代码重构

  F. 边界情况

  - 创建空文件
  - 处理特殊字符

  G. 撤销操作 (undo_edit)

  - 基础撤销操作
  - 多次撤销操作
  - 撤销新文件创建

  8. evaluation_error.xml - 错误处理测试

  - 读取不存在的文件
  - 执行产生 ZeroDivisionError 的 Python 代码

  9. evaluation_packages.xml - 包管理工具测试

  A. Node.js 包查询

  - 检查 'express' 是否已安装
  - 统计 Node.js 包数量

  B. 混合包查询

  - 同时获取 Python 和 Node.js 包

  C. 不同语言别名

  - 使用 'node' 别名
  - 使用 'py' 别名

  D. 包搜索

  - 搜索包含特定字符串的包

  E. 版本信息

  - 提取包版本号

  F. 包统计

  - 统计所有包的总数量

  10. evaluation_util.xml - 工具测试

  - 转换网页到 markdown 格式
  - 统计 markdown 中特定词汇出现次数

  11. evaluation_workflow.xml - 真实工作场景

  H. 代码审查工作流

  - 搜索包含特定关键字的 Python 文件
  - 使用 AST 解析统计函数定义数量

  I. 数据处理管道

  - 解析 XML 并统计元素数量

---

### Overview (`examples/_template/README.md`)

# Your Example Name

Brief description of what this example demonstrates.

## Quick Start

1. Start the sandbox

```bash
# Recommended: Enable API Key authentication (protects all services: API, JupyterLab, VNC)
# - Supports three methods: X-AIO-API-Key header, Authorization: Bearer header, ?api_key= query parameter
# - Without SANDBOX_API_KEY, services remain open (backward compatible)
docker run --security-opt seccomp=unconfined --rm -it \
  -e SANDBOX_API_KEY=your-secret-key \
  -p 127.0.0.1:8080:8080 ghcr.io/agent-infra/sandbox:latest
```

2. Configure the environment

```bash
# 1. Copy .env.example to .env
cp .env.example .env

# 2. Run the example
uv run main.py
```

## What This Does

Explain what happens when you run this example.

## Customize

Modify `main.py` to add your own logic.

---

### Overview (`examples/ag2-integration/README.md`)

# AG2 Integration Example

This example demonstrates how to run an AG2 multi-agent workflow against Agent Sandbox.

## Prerequisites

- A running sandbox instance at `http://localhost:8080`
- Python 3.12+
- OpenAI API key

## Quick Start

```bash
# Start sandbox
docker run --security-opt seccomp=unconfined --rm -it -p 127.0.0.1:8080:8080 ghcr.io/agent-infra/sandbox:latest

# Configure env
cp .env.example .env

# Install dependencies and run
uv sync
uv run main.py
```

## What This Example Does

1. Creates persistent Jupyter and shell sessions in the sandbox
2. Registers sandbox-backed AG2 tools for Python, shell, and file operations
3. Runs a Coder + Reviewer group chat against the Iris dataset
4. Verifies generated artifacts in `/home/gem`
5. Cleans up sandbox sessions before exit

## Optional Smoke Test

`smoke_test.ipynb` is a step-by-step notebook for validating the SDK calls used by `main.py` before running the full multi-agent flow.

---

### Overview (`examples/basic-file-operations/README.md`)

# Basic File Operations Example

This example demonstrates basic file operations with agent-sandbox, including:

- Uploading files to the sandbox
- Listing files in the sandbox
- Reading files from the sandbox
- Downloading files from the sandbox

## Prerequisites

- A running sandbox instance at `http://localhost:8080`
- Python 3.11+

## Running the Example

```bash
uv run main.py
```

## What This Example Does

1. Reads a local image file (`foo.png`)
2. Uploads it to the sandbox at `/home/sandbox/test.png`
3. Lists files in the sandbox directory
4. Reads the file back from the sandbox
5. Downloads the file from the sandbox to verify the operation

---

### Overview (`examples/browser-use-cua/README.md`)

# Browser-Use Integration Example

This example demonstrates how to integrate [browser-use](https://github.com/browser-use/browser-use) with agent-sandbox, allowing you to use browser automation agents with a sandboxed browser.

## Prerequisites

- A running sandbox instance at `http://localhost:8080`
- Python 3.11+
- OpenAI API key or compatible LLM endpoint

## Running the Example

```bash
# Set your LLM API credentials
export OPENAI_API_KEY="your_api_key"

# Run the example
uv run main.py
```

## What This Example Does

1. Connects to the sandbox browser via CDP
2. Creates a browser-use Agent with the sandboxed browser session
3. Executes an AI-driven browser automation task
4. The agent will visit DuckDuckGo and search for "browser-use founders"

## Configuration

You can modify the task in [main.py](main.py:19):

```python
agent = Agent(
    task='Visit https://duckduckgo.com and search for "browser-use founders"',
    llm=ChatOpenAI(model="gcp-claude4.1-opus"),
    tools=tools,
    browser_session=browser_session,
)
```

Update the LLM model in the code according to your setup.

---

### Overview (`examples/browser-use-integration/README.md`)

# Browser-Use Integration Example

This example demonstrates how to integrate [browser-use](https://github.com/browser-use/browser-use) with agent-sandbox, allowing you to use browser automation agents with a sandboxed browser.

## Prerequisites

- A running sandbox instance at `http://localhost:8080`
- Python 3.11+
- OpenAI API key or compatible LLM endpoint

## Running the Example

```bash
# Set your LLM API credentials
export OPENAI_API_KEY="your_api_key"

# Run the example
uv run main.py
```

## What This Example Does

1. Connects to the sandbox browser via CDP
2. Creates a browser-use Agent with the sandboxed browser session
3. Executes an AI-driven browser automation task
4. The agent will visit DuckDuckGo and search for "browser-use founders"

## Configuration

You can modify the task in [main.py](main.py:19):

```python
agent = Agent(
    task='Visit https://duckduckgo.com and search for "browser-use founders"',
    llm=ChatOpenAI(model="gcp-claude4.1-opus"),
    tools=tools,
    browser_session=browser_session,
)
```

Update the LLM model in the code according to your setup.

---

### Overview (`examples/code-execute/README.md`)

# Basic File Operations Example

This example demonstrates basic file operations with agent-sandbox, including:

- Uploading files to the sandbox
- Listing files in the sandbox
- Reading files from the sandbox
- Downloading files from the sandbox

## Prerequisites

- A running sandbox instance at `http://localhost:8080`
- Python 3.11+

## Running the Example

```bash
uv run main.py
```

## What This Example Does

1. Reads a local image file (`foo.png`)
2. Uploads it to the sandbox at `/home/sandbox/test.png`
3. Lists files in the sandbox directory
4. Reads the file back from the sandbox
5. Downloads the file from the sandbox to verify the operation

---

### Overview (`examples/langgraph-deepagents-integration/README.md`)

# aio-deepagents

A LangGraph-based deep agent implementation that uses AIO Sandbox as a native DeepAgents sandbox backend, implementing the `BaseSandbox` protocol (`execute`, `upload_files`, `download_files`).

## Features

- **Native Sandbox Backend**: Direct integration via DeepAgents sandbox protocol
- **OpenAI Compatible**: Supports various LLM providers through OpenAI-compatible API
- **Streaming Support**: Real-time response streaming

## Prerequisites

- Python 3.12 or higher
- Docker (for running AIO sandbox)
- An OpenAI-compatible API key (OpenRouter, etc.)

## Quick Start

### 1. Start AIO Docker Sandbox

**For International Users:**
```bash
docker run --security-opt seccomp=unconfined --rm -it -p 127.0.0.1:8080:8080 ghcr.io/agent-infra/sandbox:latest
```

**For Users in Mainland China:**
```bash
docker run --security-opt seccomp=unconfined --rm -it -p 127.0.0.1:8080:8080 enterprise-public-cn-beijing.cr.volces.com/vefaas-public/all-in-one-sandbox:latest
```

More information:
- [AIO Sandbox Guide](https://sandbox.agent-infra.com/)

### 2. Setup Environment

```bash
uv venv
uv sync
```

### 3. Configure Environment Variables

```bash
cp .env.example .env
```

Edit `.env` with your API details:
```bash
OPENAI_API_KEY=sk-xxxxx
OPENAI_MODEL_ID=anthropic/claude-sonnet-4
OPENAI_BASEURL=https://openrouter.ai/api/v1
SANDBOX_URL=http://localhost:8080
```

### 4. Run the Agent

```bash
uv run main.py
```

## Architecture

```
DeepAgents Agent
    └── AIOSandboxBackend (sandbox_backend.py)
        ├── execute(cmd)       → client.bash.exec()
        ├── upload_files()     → client.file.write_file()
        └── download_files()   → client.file.read_file()
            └── agent-sandbox SDK → AIO Sandbox HTTP API
```

This follows the same pattern as `langchain-daytona`, `langchain-runloop`, etc.

## Project Structure

```
aio-deepagents/
├── main.py              # Main entry point
├── sandbox_backend.py   # AIOSandboxBackend — DeepAgents sandbox protocol impl
├── pyproject.toml       # Project configuration and dependencies
├── .env.example         # Environment variables template
└── README.md            # This file
```

## Customization

- **Change the question**: Modify the content in the `astream` call in `main.py`
- **Update instructions**: Change the `system_prompt` parameter
- **Switch models**: Update the `OPENAI_MODEL_ID` environment variable

## License

This project is licensed under the terms specified in the LICENSE file.

---

### Overview (`examples/minimax-integration/README.md`)

# MiniMax Integration Example

This example demonstrates how to use [MiniMax](https://www.minimaxi.com/) models with agent-sandbox for safe code execution, leveraging MiniMax's OpenAI-compatible API.

## Prerequisites

- A running sandbox instance at `http://localhost:8080`
- Python 3.11+
- MiniMax API key ([get one here](https://platform.minimaxi.com/))

## Running the Example

```bash
# Set your MiniMax API key
export MINIMAX_API_KEY="your_api_key"

# Run the example
uv run main.py
```

You can customise the model and the task via environment variables:

```bash
MINIMAX_MODEL=MiniMax-M2.7-highspeed TASK="sort a list of 100 random numbers" uv run main.py
```

## What This Example Does

1. Connects to MiniMax via the OpenAI-compatible endpoint (`https://api.minimax.io/v1`)
2. Sends a natural-language task to a MiniMax model (default: **MiniMax-M2.7**, 204K context)
3. The model generates code and calls the `run_code` tool
4. The code is executed inside the sandbox and results are returned

## Available MiniMax Models

| Model | Context | Notes |
|---|---|---|
| `MiniMax-M2.7` | 204K | Latest, recommended |
| `MiniMax-M2.7-highspeed` | 204K | Faster, lower latency |
| `MiniMax-M2.5` | 204K | Previous generation |
| `MiniMax-M2.5-highspeed` | 204K | Previous generation, faster |

## Key Features

- **OpenAI-compatible** — uses the standard `openai` Python SDK, just with a different `base_url`
- **Safe Code Execution** — all code runs in an isolated sandbox environment
- **Multi-language Support** — supports both Python (Jupyter) and Node.js execution
- **Function Calling** — leverages MiniMax's tool-use capabilities

---

### Overview (`examples/openai-integration/README.md`)

# OpenAI Integration Example

This example demonstrates how to integrate OpenAI's function calling with agent-sandbox to enable safe code execution in a sandboxed environment.

## Prerequisites

- A running sandbox instance at `http://localhost:8080`
- Python 3.11+
- OpenAI API key

## Running the Example

```bash
# Set your OpenAI API key
export OPENAI_API_KEY="your_api_key"

# Update the API key in main.py, then run
uv run main.py
```

## What This Example Does

1. Defines a `run_code` function that executes Python or Node.js code in the sandbox
2. Registers the function as an OpenAI tool
3. Sends a natural language request to GPT-4 (e.g., "calculate 1+1")
4. GPT-4 decides to use the `run_code` tool with appropriate code
5. The code is executed in the sandbox and results are returned

## Key Features

- **Safe Code Execution**: All code runs in an isolated sandbox environment
- **Multi-language Support**: Supports both Python (via Jupyter) and Node.js execution
- **OpenAI Function Calling**: Leverages GPT's ability to generate and call functions

## Example Usage

The example is currently configured to calculate `1+1`, but you can modify the task in [main.py](main.py:21):

```python
messages=[{"role": "user", "content": "calculate 1+1"}]
```

Try different tasks like:
- "create a fibonacci sequence generator"
- "calculate the factorial of 10"
- "fetch data from an API and parse it"

---

### Overview (`examples/oss-upload/README.md`)

# Basic File Operations Example

This example demonstrates basic file operations with agent-sandbox, including:

- Uploading files to the sandbox
- Listing files in the sandbox
- Reading files from the sandbox
- Downloading files from the sandbox

## Prerequisites

- A running sandbox instance at `http://localhost:8080`
- Python 3.11+

## Running the Example

```bash
uv run main.py
```

## What This Example Does

1. Reads a local image file (`foo.png`)
2. Uploads it to the sandbox at `/home/sandbox/test.png`
3. Lists files in the sandbox directory
4. Reads the file back from the sandbox
5. Downloads the file from the sandbox to verify the operation

---

### Overview (`examples/playwright-integration/README.md`)

# Playwright Integration Example

This example demonstrates how to integrate [Playwright](https://playwright.dev) with agent-sandbox, allowing you to use Playwright's powerful browser automation capabilities with a sandboxed browser.

## Prerequisites

- A running sandbox instance at `http://localhost:8080`
- Python 3.11+
- uv package manager

## Running the Example

```bash
# Install Playwright browsers (first time only)
uv run playwright install chromium

# Run the example
uv run main.py
```

## What This Example Does

1. Connects to the sandbox browser via CDP (Chrome DevTools Protocol)
2. Creates a new browser context and page using Playwright
3. Navigates to DuckDuckGo and performs a search
4. Extracts the first search result's title and link
5. Takes a screenshot of the search results page
6. Saves the screenshot as `search_results.png`

## Configuration

You can modify the automation script in [main.py](main.py) to perform different tasks:

```python
# Navigate to a website
await page.goto("https://example.com")

# Interact with elements
await page.click('button[type="submit"]')
await page.fill('input[name="email"]', "test@example.com")

# Wait for elements
await page.wait_for_selector('.result')

# Extract data
title = await page.title()
text = await page.locator('.content').inner_text()

# Take screenshots
await page.screenshot(path="screenshot.png")
```

## Key Features

- **Browser Automation**: Full Playwright API for browser control
- **Sandboxed Execution**: Browser runs in isolated sandbox environment
- **CDP Integration**: Connect via Chrome DevTools Protocol
- **Screenshot Support**: Capture visual output
- **Element Selection**: Powerful selectors and locators
- **Async/Await**: Modern async Python patterns

## Advanced Usage

### Multiple Pages

```python
page1 = await context.new_page()
page2 = await context.new_page()

await page1.goto("https://example1.com")
await page2.goto("https://example2.com")
```

### Network Interception

```python
await page.route("**/*.{png,jpg,jpeg}", lambda route: route.abort())
```

### Emulation

```python
context = await browser.new_context(
    viewport={'width': 1280, 'height': 720},
    user_agent='Custom User Agent'
)
```

## Resources

- [Playwright Documentation](https://playwright.dev/python/docs/intro)
- [Agent Sandbox Documentation](https://sandbox.agent-infra.com)
- [Playwright Selectors Guide](https://playwright.dev/python/docs/selectors)

---

### Overview (`examples/site-to-markdown/README.md`)

# Site to Markdown Example

This example demonstrates how to combine multiple sandbox features:
- Browser automation with Playwright
- Jupyter code execution for HTML processing
- File operations

The example fetches a website, converts it to markdown, and saves it with a screenshot.

## Prerequisites

- A running sandbox instance at `http://localhost:8080`
- Python 3.11+
- Playwright installed (will be installed automatically with dependencies)

## Running the Example

```bash
# Install Playwright browsers (first time only)
uv run playwright install

# Run the example
uv run main.py
```

## What This Example Does

1. Connects to the sandbox browser via CDP
2. Navigates to a website (https://sandbox.agent-infra.com/)
3. Captures the HTML content and screenshot
4. Uses Jupyter in the sandbox to convert HTML to markdown using `markdownify`
5. Saves the markdown file with embedded screenshot
6. Downloads the result to local filesystem as `output.md`

---

### Overview (`examples/volcengine-provider/README.md`)

# Volcengine Provider Example

This example demonstrates how to use the Volcengine cloud provider to create and manage sandbox instances using the Volcengine VEFAAS API.

## Prerequisites

- Volcengine account with VEFAAS access
- Environment variables set:
  - `VOLCENGINE_ACCESS_KEY`: Your Volcengine access key
  - `VOLCENGINE_SECRET_KEY`: Your Volcengine secret key
  - `VOLCENGINE_REGION`: Region (default: cn-beijing)
- Python 3.11+

## Running the Example

```bash
export VOLCENGINE_ACCESS_KEY="your_access_key"
export VOLCENGINE_SECRET_KEY="your_secret_key"
export VOLCENGINE_REGION="cn-beijing"

uv run main.py
```

## What This Example Does

1. Creates a Volcengine application
2. Waits for the application to be ready
3. Creates a sandbox instance
4. Lists all sandboxes for the function
5. Gets sandbox details and public domain
6. Tests the sandbox by listing files
7. Deletes the sandbox instance

---

### Overview (`sdk/go/README.md`)

# Go SDK

Please refer to [https://github.com/agent-infra/sandbox-sdk-go](https://github.com/agent-infra/sandbox-sdk-go).

---

### Overview (`sdk/js/README.md`)

# @agent-infra/sandbox

Node.js/TypeScript SDK for AIO Sandbox integration, providing tools and interfaces for sandbox management and cloud provider integrations.

## Installation

```bash
npm install @agent-infra/sandbox
```

or with yarn:

```bash
yarn add @agent-infra/sandbox
```

or with pnpm:

```bash
pnpm add @agent-infra/sandbox
```

## Quick Start

### Basic Usage

```typescript
import { SandboxApiClient } from '@agent-infra/sandbox';

// Initialize the client
const client = new SandboxApiClient({
  environment: 'https://your-sandbox-api.com',
  // Add authentication if required
});

// Use the API
const result = await client.file.read({
  path: '/path/to/file',
});

console.log(result);
```

### Using Cloud Providers

The SDK includes provider implementations for managing sandboxes on different cloud platforms.

#### Volcengine Provider

```typescript
import { providers } from '@agent-infra/sandbox';

// Initialize Volcengine provider
const volcengineProvider = new providers.VolcengineProvider({
  accessKey: process.env.VOLCENGINE_ACCESS_KEY,
  secretKey: process.env.VOLCENGINE_SECRET_KEY,
  region: 'cn-beijing', // Optional, defaults to 'cn-beijing'
});

// Create a sandbox
const sandboxId = await volcengineProvider.createSandbox(
  'your-function-id',
  30 // timeout in minutes
);
console.log('Created sandbox:', sandboxId);

// Get sandbox details with APIG domains
const sandbox = await volcengineProvider.getSandbox(
  'your-function-id',
  sandboxId
);
console.log('Sandbox domains:', sandbox.domains);

// List all sandboxes for a function
const sandboxes = await volcengineProvider.listSandboxes('your-function-id');
console.log('Total sandboxes:', sandboxes.length);

// Delete a sandbox
await volcengineProvider.deleteSandbox('your-function-id', sandboxId);
console.log('Sandbox deleted');
```

#### Application Management

```typescript
// Create an application
const appId = await volcengineProvider.createApplication(
  'my-app',
  'my-gateway'
);

// Check application readiness
const [isReady, functionId] = await volcengineProvider.getApplicationReadiness(appId);
if (isReady) {
  console.log('Application is ready, function ID:', functionId);
}

// Get APIG domains for a function
const domains = await volcengineProvider.getApigDomains('your-function-id');
console.log('Available domains:', domains);
```

## Features

### Sandbox API Client

- **File Operations**: Read, write, search, and manage files
- **Shell Execution**: Execute shell commands and manage sessions
- **Browser Automation**: Control browser actions and retrieve information
- **Code Execution**: Execute code in various languages (Python, Node.js, Jupyter)
- **MCP Integration**: Execute MCP (Model Context Protocol) tools

### Cloud Providers

#### Volcengine Provider

- ✅ Sandbox lifecycle management (create, delete, get, list)
- ✅ Application deployment and monitoring
- ✅ APIG (API Gateway) domain management
- ✅ Automatic request signing with HMAC-SHA256
- ✅ Support for temporary credentials

#### Extensible Provider System

Create custom providers by extending the `BaseProvider` class:

```typescript
import { providers } from '@agent-infra/sandbox';

class MyCustomProvider extends providers.BaseProvider {
  async createSandbox(functionId: string, ...kwargs: any[]): Promise<any> {
    // Your implementation
  }

  async deleteSandbox(functionId: string, sandboxId: string, ...kwargs: any[]): Promise<any> {
    // Your implementation
  }

  async getSandbox(functionId: string, sandboxId: string, ...kwargs: any[]): Promise<any> {
    // Your implementation
  }

  async listSandboxes(functionId: string, ...kwargs: any[]): Promise<any> {
    // Your implementation
  }
}
```

## API Reference

### SandboxApiClient

The main client for interacting with the Sandbox API.

```typescript
const client = new SandboxApiClient({
  environment: string,          // API base URL
  timeout?: number,             // Request timeout in milliseconds
  headers?: Record<string, string>, // Custom headers
});
```

#### Available Modules

- `client.file` - File operations
- `client.shell` - Shell command execution
- `client.browser` - Browser automation
- `client.code` - Code execution
- `client.jupyter` - Jupyter notebook operations
- `client.nodejs` - Node.js specific operations
- `client.mcp` - MCP tool execution

### Providers

#### BaseProvider (Abstract)

Base class for all cloud provider implementations.

**Methods:**
- `createSandbox(functionId: string, ...kwargs: any[]): Promise<any>`
- `deleteSandbox(functionId: string, sandboxId: string, ...kwargs: any[]): Promise<any>`
- `getSandbox(functionId: string, sandboxId: string, ...kwargs: any[]): Promise<any>`
- `listSandboxes(functionId: string, ...kwargs: any[]): Promise<any>`

#### VolcengineProvider

Volcengine VEFAAS implementation.

**Constructor Options:**
```typescript
{
  accessKey: string;              // Volcengine access key ID
  secretKey: string;              // Volcengine secret access key
  region?: string;                // Region (default: 'cn-beijing')
  clientSideValidation?: boolean; // Enable validation (default: true)
}
```

**Additional Methods:**
- `createApplication(name: string, gatewayName: string): Promise<string | null>`
- `getApplicationReadiness(id: string): Promise<[boolean, string | null]>`
- `getApigDomains(functionId: string): Promise<DomainInfo[]>`

## Environment Variables

Configure Volcengine credentials using environment variables:

```bash
# Volcengine credentials (option 1)
VOLCENGINE_ACCESS_KEY=your-access-key
VOLCENGINE_SECRET_KEY=your-secret-key

# Volcengine credentials (option 2)
VOLC_ACCESSKEY=your-access-key
VOLC_SECRETKEY=your-secret-key
```

## TypeScript Support

This package is written in TypeScript and includes full type definitions. TypeScript 5.0+ is recommended.

```typescript
import type {
  SandboxApi,
  BaseClientOptions,
  BaseRequestOptions
} from '@agent-infra/sandbox';
```

## Examples

### Execute Shell Command

```typescript
const result = await client.shell.exec({
  command: 'ls -la',
  timeout: 5000,
});
console.log(result.stdout);
```

### Read File

```typescript
const fileContent = await client.file.read({
  path: '/path/to/file.txt',
});
console.log(fileContent.content);
```

### Browser Automation

```typescript
const browserInfo = await client.browser.info();
console.log('Browser:', browserInfo);

await client.browser.config({
  action: {
    type: 'click',
    selector: '#button',
  },
});
```

### Execute Python Code

```typescript
const result = await client.code.execute({
  code: 'print("Hello from sandbox!")',
  language: 'python',
});
console.log(result.output);
```

## Error Handling

```typescript
import { SandboxApiError, SandboxApiTimeoutError } from '@agent-infra/sandbox';

try {
  const result = await client.file.read({ path: '/nonexistent' });
} catch (error) {
  if (error instanceof SandboxApiTimeoutError) {
    console.error('Request timed out');
  } else if (error instanceof SandboxApiError) {
    console.error('API error:', error.statusCode, error.message);
  } else {
    console.error('Unexpected error:', error);
  }
}
```

## Development

### Project Structure

```
sdk/js/
├── src/              # TypeScript source code
│   ├── api/          # Generated API modules
│   ├── core/         # Core utilities
│   ├── errors/       # Error classes
│   ├── providers/    # Cloud provider implementations (custom code)
│   │   ├── base.ts       # Base provider interface
│   │   ├── volcengine.ts # Volcengine implementation
│   │   ├── sign.ts       # Request signing utilities
│   │   └── README.md     # Provider documentation
│   ├── BaseClient.ts # Base client implementation
│   ├── Client.ts     # Main API client
│   └── index.ts      # Package entry point
├── dist/             # Compiled JavaScript output (generated by build)
├── package.json      # Package configuration
└── tsconfig.json     # TypeScript configuration
```

### Building

The SDK uses TypeScript and compiles source code from `src/` to `dist/`:

```bash
npm run build
```

This will:
1. Compile TypeScript files from `src/` to JavaScript in `dist/`
2. Generate `.d.ts` type definition files
3. Generate source maps for debugging

### Testing

```bash
npm test

# With coverage
npm run test:coverage

# With UI
npm run test:ui
```

### Development Mode

```bash
npm run dev  # Watch mode with auto-rebuild
```

### Generating SDK

The base SDK code is generated using [Fern](https://buildwithfern.com/):

```bash
cd sdk/fern
fern generate --group nodejs-sdk --local
```

This generates TypeScript code from the OpenAPI specification into `src/`.
Custom providers in `src/providers/` are preserved via `.fernignore`.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

### Adding Custom Providers

See [providers/README.md](./providers/README.md) for detailed information on implementing custom cloud providers.

## License

ISC

## Links

- [Repository](https://github.com/agent-infra/sandbox-sdk)
- [Issues](https://github.com/agent-infra/sandbox-sdk/issues)
- [Volcengine Documentation](https://www.volcengine.com/docs/)

## Support

For questions and support, please open an issue on GitHub.

---

**Version**: 1.0.0
**Node.js**: >=18.0.0
**TypeScript**: >=5.0.0

---

### Overview (`sdk/python/README.md`)

# Agent Sandbox Python SDK

A Python SDK for the All-in-One Sandbox API, providing access to sandbox, shell, file, jupyter, nodejs, and mcp services.

## Installation

```bash
pip install agent-sandbox
```

## Usage

```python
from agent_sandbox import Sandbox

client = Sandbox(base_url="http://localhost:8091")

ctx = client.sandbox.get_context()
print(ctx)

result = client.shell.exec_command(command="ls -la")
print(result)
```

## Async Support

The SDK also provides async support through the `AsyncSandbox` class:

```python
import asyncio
from agent_sandbox import AsyncSandbox

async def main():
    client = AsyncSandbox(base_url="http://localhost:8091")
    
    # Get sandbox context
    ctx = await client.sandbox.get_context()
    print(ctx)

    result = await client.shell.exec_command(command="ls -la")
    print(result)

asyncio.run(main())
```

## Cloud Providers

### Volcengine

Create a sandbox instance using the Volcengine provider. For more details, please refer to [examples/provider_volcengine.py](examples/provider_volcengine.py).

```
from __future__ import print_function

import os
import sys

# Add the parent directory to Python path so we can import agent_sandbox
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from agent_sandbox.providers import VolcengineProvider


def main():
    """
    Main function demonstrating Volcengine provider usage.
    """
    # Configuration - replace with your actual credentials
    access_key = os.getenv("VOLC_ACCESSKEY")
    secret_key = os.getenv("VOLC_SECRETKEY")
    region = os.getenv("VOLCENGINE_REGION", "cn-beijing")
    
    # Initialize the Volcengine provider
    provider = VolcengineProvider(
        access_key=access_key,
        secret_key=secret_key,
        region=region
    )
    
    print("=== Volcengine Sandbox Provider Example ===\n")
    
    function_id = "yatoczqh"
    
    print("1. Creating a sandbox...")
    sandbox_id = provider.create_sandbox(function_id=function_id)
    print(f"Create response: {sandbox_id}")


if __name__ == "__main__":
    main()
```

## Features

- **Sandbox**: Access sandbox environment information and installed packages
- **Shell**: Execute shell commands with session management
- **File**: Read, write, search, and manage files
- **Jupyter**: Execute Python code in Jupyter kernels
- **Node.js**: Execute JavaScript code in Node.js environment
- **MCP**: Interact with Model Context Protocol servers

## Requirements

- Python 3.8+
- httpx
- pydantic
- typing_extensions (for Python < 3.10)

---

### Overview (`website/diagrams/README.md`)

# Diagram sources

Archify specs (skill `tt-a1i/archify`). Regenerate with
`node bin/archify.mjs deliver <type> <name>.<type>.json <name>.html --quality showcase`,
then export SVG from the delivered viewer into `docs/public/architecture/<name>.svg`:

- `aiod-overview.architecture.json` — the Introduction hero.
- `aiod-permission-model.architecture.json` — the permission model (Daemon → Architecture).
- `aiod-browser-cdp.architecture.json` — the two browser paths (Daemon → Browser API).
- `aiod-jupyter-kernel.architecture.json` — the kernels aiod spawns (Daemon → Jupyter).
- `aiod-human-in-loop.architecture.json` — agent and person on the same objects (Daemon → Computer Use).
- `aiod-mcp-flow.architecture.json` — one endpoint, one tool list (Daemon → examples → MCP).
- `aio-sandbox-overview.architecture.json` — the surfaces inside the container (Guide → Introduction).
- `aio-agent-calls-sandbox.architecture.json` — agent outside, capabilities inside (Guide → Agent Call Sandbox vs In Sandbox).
- `aio-agent-in-sandbox.architecture.json` — agent process inside the container (Guide → Agent Call Sandbox vs In Sandbox).
- `aiod-existing-environment.architecture.json` — aiod added into an existing container, VM or desktop (Daemon → Introduction).
- `aiod-watch-flow.sequence.json` — watch, poll, stop (Daemon → Files, Daemon → examples → file ops).
- `aiod-code-execution-flow.sequence.json` — dataset in, chart out (Daemon → examples → code execution).
- `aiod-code-backends.sequence.json` — which backend runs the code (Daemon → Code).
- `aiod-browser-use-flow.sequence.json` — serve a page, then drive it (Daemon → examples → browser use).
- `aiod-terminal-flow.sequence.json` — create, attach, run (Daemon → examples → terminal).
- `aiod-terminal-reconnect.sequence.json` — reattach with and without durable (Daemon → examples → terminal).
- `aiod-computer-action.sequence.json` — one computer action, then the accessibility tree (Daemon → Computer Use).

`*.html` without a matching spec are hand-drawn SVG sources; the `<svg>` element is
extracted verbatim into `docs/public/architecture/<name>.svg`.

`aiod-capabilities.gen.py` writes the capability status board straight to `docs/public/architecture/aiod-capabilities.svg`.

---

### Overview (`website/docs/README.md`)

# AIO Sandbox Documentation

This documentation provides comprehensive guides and API references for the AIO Sandbox environment.

## 📚 Documentation Structure

```
docs/
├── index.md          # Homepage with overview
├── guide/            # User guides and tutorials
│   ├── quick-start.md
│   └── ...
├── api/              # API reference documentation
│   ├── index.md      # API overview
│   ├── swagger.md    # Interactive API docs guide
│   ├── file.md       # File operations API
│   ├── shell.md      # Shell & terminal API
│   ├── browser.md    # Browser automation API
│   └── mcp.md        # MCP services API
└── examples/         # Practical examples
    ├── agent.md
    ├── browser.md
    └── terminal.md
```

## 🚀 Viewing Documentation

### Local Development
If you're running the documentation locally:
```bash
# Install dependencies
npm install

# Start dev server
npm run docs:dev

# Build for production
npm run docs:build
```

### Live API Documentation
When AIO Sandbox is running, access the interactive Swagger UI at:
- **Swagger UI**: http://localhost:8080/v1/docs
- **OpenAPI Spec**: http://localhost:8080/openapi.json

## 📖 Key Sections

### For Users
- **[Quick Start](/en/guide/start/quick-start)** - Get up and running in minutes
- **[Features Guide](/en/guide/start/introduction)** - Explore all capabilities
- **[Examples](/en/examples/)** - Real-world use cases

### For Developers
- **[API Reference](/en/api/)** - Complete API documentation with interactive Swagger UI

## 🛠️ API Integration

### Generate Client SDKs
Use the OpenAPI specification to generate client libraries:

```bash
# Install OpenAPI Generator
npm install @openapitools/openapi-generator-cli

# Generate Python client
openapi-generator-cli generate \
  -i http://localhost:8080/openapi.json \
  -g python \
  -o ./python-client

# Generate TypeScript client
openapi-generator-cli generate \
  -i http://localhost:8080/openapi.json \
  -g typescript-axios \
  -o ./typescript-client
```

### Import to API Tools
- **Postman**: Import → URL → `http://localhost:8080/openapi.json`
- **Insomnia**: Import → From URL → `http://localhost:8080/openapi.json`
- **Bruno**: Import → OpenAPI → `http://localhost:8080/openapi.json`

## 📝 Documentation Updates

The documentation is automatically generated from:
1. **OpenAPI Specification** (`/openapi.json`) - API endpoints and schemas
2. **Markdown Files** - Guides, examples, and additional content
3. **Code Comments** - Inline documentation in source code

To update documentation:
1. Modify the relevant markdown files in `/docs`
2. Update OpenAPI spec for API changes
3. Run build to generate updated docs

## 🤝 Contributing

Contributions to documentation are welcome! Please:
1. Follow the existing structure and style
2. Write from a user perspective
3. Include practical examples
4. Test all code samples
5. Update the OpenAPI spec for API changes

## 📚 Resources

- **GitHub Repository**: https://github.com/agent-infra/sandbox
- **Issue Tracker**: https://github.com/agent-infra/sandbox/issues
- **Docker Hub**: https://hub.docker.com/r/agent-infra/sandbox

## 📄 License

This documentation is part of the AIO Sandbox project and follows the same license terms.

---

### Overview (`sdk/js/examples/README.md`)

# Sandbox SDK Examples

TypeScript examples demonstrating usage of the `@agent-infra/sandbox` SDK.

## Examples

### 1. simple-examples.ts
Basic, straightforward examples covering core SDK functionality:
- Getting sandbox context
- Executing shell commands
- Running Python code
- File operations (write, read, list, find, search)

### 2. basic-usage.ts
Fundamental sandbox operations:
- Sandbox context retrieval
- Shell command execution
- Python code execution
- File read/write operations
- Directory listing
- Python package information

### 3. volcengine-provider.ts
Volcengine cloud provider integration:
- Creating sandboxes with configuration
- Getting sandbox information
- Listing sandboxes
- Deleting sandboxes

### 4. advanced-usage.ts
Comprehensive demonstration of SDK features:
- File operations (read, write, list, search, find)
- Code execution (Python, JavaScript, Node.js)
- Shell commands
- Volcengine provider workflow

### 5. error-handling.ts
Error handling patterns and resilience strategies:
- Error type detection and handling
- Retry logic with exponential backoff
- Circuit breaker pattern
- Graceful degradation

## Running Examples

Install dependencies first:
```bash
npm install
```

Run individual examples:
```bash
npm run simple      # Simple examples
npm run basic       # Basic usage
npm run volcengine  # Volcengine provider
npm run advanced    # Advanced usage
npm run error       # Error handling
```

Run all examples:
```bash
npm run all
```

## Environment Variables

For Volcengine examples:
```bash
export VOLCENGINE_ACCESS_KEY=your-access-key
export VOLCENGINE_SECRET_KEY=your-secret-key
```

For custom sandbox URL:
```bash
export SANDBOX_API_URL=http://your-sandbox:8080
```

## Type Checking

Check TypeScript types:
```bash
npm run build
```

### Known SDK Issues

The SDK source has several TypeScript compilation errors that prevent clean builds:

1. **Missing errors module** (`./errors/index.js`): The `SandboxError` and `SandboxTimeoutError` classes are exported but the module doesn't exist
2. **HeadersIterator type**: DOM type `HeadersIterator` is not found
3. **Buffer/Blob compatibility**: Type incompatibility between Node.js Buffer and DOM Blob
4. **APIResponse error property**: Many client methods try to access `.error` on wrong response type

**These are SDK build issues, not example code issues.** All example TypeScript code is syntactically correct and will run properly with `tsx` even though `tsc` reports errors from the SDK internals.

To run examples without type checking:
```bash
npx tsx simple-examples.ts
npx tsx basic-usage.ts
# etc.
```

## Example Code Patterns

### API Response Pattern
All SDK methods return `APIResponse<T, E>` with `.ok` discriminator:

```typescript
const response = await client.file.readFile({ file: '/tmp/test.txt' });

if (response.ok) {
  console.log('Success:', response.body);
} else {
  console.error('Error:', response.error);
}
```

### Error Handling
```typescript
try {
  const response = await client.shell.execCommand({
    command: 'echo "Hello"'
  });
  
  if (!response.ok) {
    console.error('Command failed');
  }
} catch (error) {
  if (error instanceof Error) {
    console.error('Error:', error.message);
  }
}
```

### File Operations
```typescript
// Write
await client.file.writeFile({
  file: '/tmp/test.txt',
  content: 'Hello World'
});

// Read
const read = await client.file.readFile({ 
  file: '/tmp/test.txt' 
});

// List
const list = await client.file.listPath({ 
  path: '/tmp' 
});

// Search
const search = await client.file.searchInFile({
  file: '/tmp/test.txt',
  regex: 'pattern'
});

// Find
const find = await client.file.findFiles({
  path: '/tmp',
  glob: '*.txt'
});
```

### Code Execution
```typescript
// Python
await client.code.executeCode({
  language: 'python',
  code: 'print("Hello from Python!")'
});

// JavaScript
await client.code.executeCode({
  language: 'javascript',
  code: 'console.log("Hello from JS!")'
});

// Node.js
await client.nodejs.executeCode({
  code: 'console.log(process.version)'
});
```

---

### Overview (`sdk/js/src/providers/README.md`)

# Sandbox Providers

This directory contains custom cloud provider implementations for sandbox management.

## Volcengine Provider

The Volcengine provider integrates with Volcengine VEFAAS (Volcengine Function as a Service) API to manage sandbox instances.

### Installation

The provider is included in the `@agent-infra/sandbox` package. Install it via npm:

```bash
npm install @agent-infra/sandbox
```

### Usage

```typescript
import { providers } from '@agent-infra/sandbox';

// Initialize the Volcengine provider
const provider = new providers.VolcengineProvider({
  accessKey: 'your-access-key',
  secretKey: 'your-secret-key',
  region: 'cn-beijing', // Optional, defaults to 'cn-beijing'
  clientSideValidation: true, // Optional, defaults to true
});

// Create a sandbox
const sandboxId = await provider.createSandbox('function-id', 30);

// Get sandbox details
const sandbox = await provider.getSandbox('function-id', sandboxId);

// List all sandboxes
const sandboxes = await provider.listSandboxes('function-id');

// Delete a sandbox
await provider.deleteSandbox('function-id', sandboxId);

// Set sandbox timeout
await provider.setSandboxTimeout('function-id', sandboxId, 120);
```

### Application Management

The provider also supports application lifecycle management:

```typescript
// Create an application
const applicationId = await provider.createApplication('app-name', 'gateway-name');

// Check application readiness
const [isReady, functionId] = await provider.getApplicationReadiness(applicationId);

// Get APIG domains for a function
const domains = await provider.getApigDomains('function-id');
```

## Custom Providers

To create a custom provider, extend the `BaseProvider` class:

```typescript
import { providers } from '@agent-infra/sandbox';

class MyCustomProvider extends providers.BaseProvider {
  async createSandbox(functionId: string, ...kwargs: any[]): Promise<any> {
    // Implementation
  }

  async deleteSandbox(functionId: string, sandboxId: string, ...kwargs: any[]): Promise<any> {
    // Implementation
  }

  async getSandbox(functionId: string, sandboxId: string, ...kwargs: any[]): Promise<any> {
    // Implementation
  }

  async listSandboxes(functionId: string, ...kwargs: any[]): Promise<any> {
    // Implementation
  }
}
```

## API Reference

### BaseProvider (Abstract)

Base class for all cloud provider implementations.

#### Methods

- `createSandbox(functionId: string, ...kwargs: any[]): Promise<any>`
- `deleteSandbox(functionId: string, sandboxId: string, ...kwargs: any[]): Promise<any>`
- `getSandbox(functionId: string, sandboxId: string, ...kwargs: any[]): Promise<any>`
- `listSandboxes(functionId: string, ...kwargs: any[]): Promise<any>`

### VolcengineProvider

Volcengine VEFAAS implementation of the BaseProvider.

#### Constructor Options

- `accessKey` (string): Volcengine access key ID
- `secretKey` (string): Volcengine secret access key
- `region` (string, optional): Volcengine region, defaults to 'cn-beijing'
- `clientSideValidation` (boolean, optional): Enable client-side validation, defaults to true

#### Additional Methods

- `createApplication(name: string, gatewayName: string, ...kwargs: any[]): Promise<string | null>`
- `getApplicationReadiness(id: string, ...kwargs: any[]): Promise<[boolean, string | null]>`
- `getApigDomains(functionId: string): Promise<DomainInfo[]>`
- `setSandboxTimeout(functionId: string, sandboxId: string, timeout: number): Promise<any>`

## Environment Variables

For the Volcengine provider, you can also configure credentials using environment variables:

- `VOLCENGINE_ACCESS_KEY`
- `VOLCENGINE_SECRET_KEY`

## License

Apache License 2.0

---

### Overview (`sdk/python/agent_sandbox/providers/README.md`)

# Cloud Providers

This module contains cloud provider implementations for sandbox management.

## Volcengine

The Volcengine provider integrates with Volcengine VEFAAS APIs to manage sandbox instances.

```python
from agent_sandbox.providers import VolcengineProvider

provider = VolcengineProvider(
    access_key="your-access-key",
    secret_key="your-secret-key",
    region="cn-beijing",
)

sandbox_id = provider.create_sandbox("function-id", timeout=30)
sandbox = provider.get_sandbox("function-id", sandbox_id)
sandboxes = provider.list_sandboxes("function-id")
provider.set_sandbox_timeout("function-id", sandbox_id, 120)
provider.delete_sandbox("function-id", sandbox_id)
```

---

### En Index (`website/docs/en/index.md`)

---
pageType: home

hero:
  name: AIO Sandbox
  text: |
    All-in-One Environment
    for AI Agents
  tagline: |
    🌐 Browser | 💻 Terminal | 📁 File

    🔧 VSCode | 📊 Jupyter | <img src="/icons/mcp.png" style="display: inline-block; width: 1.2em; height: 1.2em; vertical-align: -0.25em; margin-right: 4px;" /> MCP
  actions:
    - theme: brand
      text: Get Started
      link: /guide/start/introduction
    - theme: alt
      text: GitHub
      link: https://github.com/agent-infra/sandbox
  image:
    src: /aio-icon.png
    alt: AIO Sandbox Logo

features:
  - title: Unified Environment
    details: One Docker container with shared filesystem. Files downloaded in the browser are instantly accessible in Terminal and VSCode.
    icon: 🌐
  - title: Out of the Box
    details: Built‑in VNC browser, VS Code, Jupyter, file manager, and terminal—accessible directly via API/SDK.
    icon: ⚡
  - title: Secure Execution
    details: Isolated Python and Node.js sandboxes. Safe code execution without system risks.
    icon: 🔐
  - title: Agent-Ready
    details: Pre-configured MCP Server with Browser, File, Terminal, Markdown, Ready-to-use for AI agents.
    icon: 🤖
  - title: Developer Friendly
    details: Cloud-based VSCode with persistent terminals, intelligent port forwarding(via `${Port}-${domain}/` or `/proxy`), and instant frontend/backend previews.
    icon: 🔧
  - title: Production Ready
    details: Enterprise-grade Docker deployment. Lightweight, scalable.
    icon: 🚀
---

---

### Zh Index (`website/docs/zh/index.md`)

---
pageType: home

hero:
  name: AIO Sandbox
  text: |
    面向 AI Agents 的
    一体化沙盒环境
  tagline: |
    🌐 浏览器 | 💻 终端 | 📁 文件

    🔧 VSCode | 📊 Jupyter | <img src="/icons/mcp.png" style="display: inline-block; width: 1.2em; height: 1.2em; vertical-align: -0.25em; margin-right: 4px;" /> MCP
  actions:
    - theme: brand
      text: 开始使用
      link: /zh/guide/start/introduction
    - theme: alt
      text: GitHub
      link: https://github.com/agent-infra/sandbox
  image:
    src: /aio-icon.png
    alt: AIO Sandbox Logo

features:
  - title: 统一环境
    details: 单一 Docker 容器，共享文件系统。浏览器下载的文件可在终端和 VSCode 中即时访问。
    icon: 🌐
  - title: 开箱即用
    details: 内置 VNC 浏览器、VS Code、Jupyter、文件管理器和终端——均可通过 API/SDK 直接访问。
    icon: ⚡
  - title: 安全执行
    details: 隔离的 Python 和 Node.js 沙盒。安全执行代码，无系统风险。
    icon: 🔐
  - title: AI Agent 就绪
    details: 预配置 MCP 服务器，包含浏览器、文件、终端、Markdown。为 AI Agent 准备就绪。
    icon: 🤖
  - title: 开发者友好
    details: 基于云的 VSCode，具有持久终端、智能端口转发（通过 `${Port}-${domain}/` 或 `/proxy`）和即时前端/后端预览。
    icon: 🔧
  - title: 生产就绪
    details: 企业级 Docker 部署。轻量级、可扩展。
    icon: 🚀
---

---

### En Blog Index (`website/docs/en/blog/index.mdx`)

---
title: Overview
sidebar: false
---

# AIO Sandbox Blog

Check here for the latest articles and release announcements about AIO Sandbox.

## [AIO Sandbox: An Integrated and Customizable Sandbox Environment for AI Agents](/blog/announcing-0)

> October 29, 2025

AIO Sandbox integrates all capabilities through a Docker image, providing a unified file system and authentication, and supports image customization, thereby enhancing the efficiency of Agent task execution and delivery.

---

### En Examples Index (`website/docs/en/examples/index.md`)

# Examples

This section provides practical examples and integration guides for using AIO Sandbox in real-world scenarios.

## Quick Examples

### Terminal Integration
Learn how to integrate the WebSocket terminal into your applications:
- [Basic Terminal Client](/examples/terminal) - Simple terminal integration
- [Advanced Terminal Features](/examples/terminal#advanced-features) - Session management and reconnection

### Browser Automation
Explore browser automation capabilities:
- [Browser Use Integration](/examples/browser) - Python browser automation
- [Playwright Integration](/examples/browser#playwright) - Advanced browser control
- [Web Scraping Examples](/examples/browser#scraping) - Data extraction patterns

### Agent Integration
Build AI agents with AIO Sandbox:
- [Basic Agent Setup](/examples/agent) - Connect agents to sandbox
- [MCP Integration](/examples/agent#mcp) - Use Model Context Protocol
- [Multi-Tool Workflows](/examples/agent#workflows) - Combine multiple APIs

## Integration Patterns

### Docker Compose Setup
```yaml
version: '3.8'
services:
  aio-sandbox:
    image: ghcr.io/agent-infra/sandbox:latest
    ports:
      - "127.0.0.1:8080:8080"
    volumes:
      - sandbox_data:/workspace
    restart: unless-stopped

volumes:
  sandbox_data:
```

### Kubernetes Deployment
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: aio-sandbox
spec:
  replicas: 2
  selector:
    matchLabels:
      app: aio-sandbox
  template:
    metadata:
      labels:
        app: aio-sandbox
    spec:
      containers:
      - name: sandbox
        image: ghcr.io/agent-infra/sandbox:latest
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "1Gi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "1000m"
---
apiVersion: v1
kind: Service
metadata:
  name: aio-sandbox-service
spec:
  selector:
    app: aio-sandbox
  ports:
  - port: 80
    targetPort: 8080
  type: ClusterIP
```

## SDK Examples

### Python SDK

Install the Python SDK for AIO Sandbox:

```bash
pip install aio-sandbox
```

#### Basic Configuration

Import and configure the Python client:

```python
from aio_sandbox import AioClient
import asyncio

# Initialize the client
client = AioClient(
    base_url="http://localhost:8080",  # AIO Sandbox URL
    timeout=30.0,  # Request timeout in seconds
    retries=3,     # Number of retry attempts
    retry_delay=1.0  # Delay between retries
)
```

#### Shell Operations

Execute shell commands and manage sessions:

```python
async def shell_example():
    # Execute a simple command
    result = await client.shell.exec(command="ls -la")

    if result.success:
        print(f"Output: {result.data.output}")
        print(f"Exit code: {result.data.exit_code}")

    # Execute with session management
    session_id = "my-session-1"
    await client.shell.exec(
        command="cd /workspace && pwd",
        session_id=session_id
    )

    # Continue in the same session
    result = await client.shell.exec(
        command="ls",
        session_id=session_id
    )

    # Asynchronous execution for long-running tasks
    await client.shell.exec(
        command="python long_script.py",
        async_mode=True,
        session_id=session_id
    )

    # View session output
    view_result = await client.shell.view(session_id=session_id)
    print(view_result.data.output)

# Run the example
asyncio.run(shell_example())
```

#### File Operations

Manage files and directories:

```python
async def file_example():
    # Write a file
    await client.file.write(
        file="/tmp/example.py",
        content="""
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.plot(x, y)
plt.savefig('/tmp/plot.png')
print("Plot saved!")
        """.strip()
    )

    # Read file content
    content = await client.file.read(file="/tmp/example.py")
    if content.success:
        print(f"File content:\n{content.data.content}")

    # List directory contents
    files = await client.file.list(
        path="/tmp",
        recursive=True,
        include_size=True
    )

    for file_info in files.data.files:
        print(f"{file_info.name}: {file_info.size} bytes")

    # Search in files
    search_result = await client.file.search(
        file="/tmp/example.py",
        regex=r"import \w+"
    )

    if search_result.success:
        for match in search_result.data.matches:
            print(f"Line {match.line}: {match.content}")

    # Find files by pattern
    found_files = await client.file.find(
        path="/tmp",
        glob="*.py"
    )

asyncio.run(file_example())
```

#### Code Execution

Execute Python and JavaScript code securely:

```
/* Detailed source-code truncated for AI context efficiency. */
```

#### MCP Integration

Work with Model Context Protocol services:

```python
async def mcp_example():
    # List available MCP servers
    servers = await client.mcp.list_servers()
    print("Available MCP servers:", servers.data)

    # Get tools from a specific server
    browser_tools = await client.mcp.list_tools(server_name="browser")

    for tool in browser_tools.data.tools:
        print(f"Tool: {tool.name}")
        print(f"Description: {tool.description}")

    # Execute a tool
    screenshot_result = await client.mcp.execute_tool(
        server_name="browser",
        tool_name="screenshot",
        arguments={
            "url": "https://example.com",
            "width": 1920,
            "height": 1080
        }
    )

    if screenshot_result.success:
        # Save screenshot data
        await client.file.write(
            file="/tmp/screenshot.png",
            content=screenshot_result.data.content[0].data,  # Base64 image data
            append=False
        )

asyncio.run(mcp_example())
```

#### Error Handling and Best Practices

```python
async def robust_example():
    try:
        # Always use context managers for resource cleanup
        async with AioClient("http://localhost:8080") as client:
            # Set up error handling
            result = await client.shell.exec("potentially-failing-command")

            if not result.success:
                print(f"Command failed: {result.message}")
                if hasattr(result, 'error_code'):
                    print(f"Error code: {result.error_code}")

            # Check sandbox status
            status = await client.sandbox.get_context()
            print(f"Sandbox uptime: {status.data.uptime}")
            print(f"Available packages: {len(status.data.packages)}")

    except Exception as e:
        print(f"Connection error: {e}")

asyncio.run(robust_example())
```


### Node.js SDK

To install the SDK, use the following command:

```bash
npm install @agent-infra/sandbox
```


#### Basic Configuration

Start by importing the SDK and configuring the client:

```typescript
import { AioClient } from "@agent-infra/sandbox";

const client = new AioClient({
  baseUrl: `https://{aio.sandbox.example}`, //The Url and Port should consistent with the Aio Sandbox
  timeout: 30000, // Optional: request timeout in milliseconds
  retries: 3, // Optional: number of retry attempts
  retryDelay: 1000, // Optional: delay between retries in milliseconds
});
```

#### Shell Execution

Execute shell commands within the sandbox:

```typescript
const response = await client.shellExec({
  command: "ls -la",
});

if (response.success) {
  console.log("Command Output:", response.data.output);
} else {
  console.error("Error:", response.message);
}

// Asynchronous rotation training results, suitable for long-term tasks
const response = await client.shellExecWithPolling({
  command: "ls -la",
  maxWaitTime: 60 * 1000,
});
```

#### File Management

List files in a directory:

```typescript
const fileList = await client.fileList({
  path: "/home/gem",
  recursive: true,
});

if (fileList.success) {
  console.log("Files:", fileList.data.files);
} else {
  console.error("Error:", fileList.message);
}
```

#### Jupyter Code Execution

Run Jupyter notebook code:

```typescript
const jupyterResponse = await client.jupyterExecute({
  code: "print('Hello, Jupyter!')",
  kernel_name: "python3",
});

if (jupyterResponse.success) {
  console.log("Output:", jupyterResponse.data);
} else {
  console.error("Error:", jupyterResponse.message);
}
```

## Next Steps

Ready to implement these patterns? Choose your path:

- **[Terminal Examples](/examples/terminal)** - Start with terminal integration
- **[Browser Examples](/examples/browser)** - Explore browser automation
- **[Agent Integration](/examples/agent)** - Build AI-powered workflows

For additional support:
- Check the [API documentation](/api/) for detailed specifications
- Explore the [GitHub repository](https://github.com/agent-infra/sandbox) for latest updates

---

### Zh Blog Index (`website/docs/zh/blog/index.mdx`)

---
title: 总览
sidebar: false
---

# AIO Sandbox 博客

在此查看有关 AIO Sandbox 的最新文章和发布公告。

## [AIO Sandbox：为 AI Agent 打造的一体化、可定制的沙箱环境](/blog/announcing-0)

> 2025 年 10 月 29 日

AIO Sandbox 通过一个 Docker 镜像整合所有能力，提供统一文件系统与鉴权，并支持镜像定制，提升了 Agent 任务执行与交付效率。

---

### Zh Examples Index (`website/docs/zh/examples/index.md`)

# 示例

本节提供使用 AIO Sandbox 在实际场景中的实用示例和集成指南。

## 快速示例

### 终端集成
了解如何将 WebSocket 终端集成到您的应用程序中：
- [基本终端客户端](/examples/terminal) - 简单的终端集成
- [高级终端功能](/examples/terminal#advanced-features) - 会话管理和重连

### 浏览器自动化
探索浏览器自动化功能：
- [Browser Use 集成](/examples/browser) - Python 浏览器自动化
- [Playwright 集成](/examples/browser#playwright) - 高级浏览器控制
- [Web 抓取示例](/examples/browser#scraping) - 数据提取模式

### Agent 集成
使用 AIO Sandbox 构建 AI Agent：
- [基本 Agent 设置](/examples/agent) - 将 Agent 连接到沙盒
- [MCP 集成](/examples/agent#mcp) - 使用模型上下文协议
- [多工具工作流](/examples/agent#workflows) - 组合多个 API

## 集成模式

### Docker Compose 设置
```yaml
version: '3.8'
services:
  aio-sandbox:
    image: ghcr.io/agent-infra/sandbox:latest
    ports:
      - "127.0.0.1:8080:8080"
    volumes:
      - sandbox_data:/workspace
    restart: unless-stopped

volumes:
  sandbox_data:
```

### Kubernetes 部署
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: aio-sandbox
spec:
  replicas: 2
  selector:
    matchLabels:
      app: aio-sandbox
  template:
    metadata:
      labels:
        app: aio-sandbox
    spec:
      containers:
      - name: sandbox
        image: ghcr.io/agent-infra/sandbox:latest
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "1Gi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "1000m"
---
apiVersion: v1
kind: Service
metadata:
  name: aio-sandbox-service
spec:
  selector:
    app: aio-sandbox
  ports:
  - port: 80
    targetPort: 8080
  type: ClusterIP
```

## SDK 示例

### Python SDK

安装 AIO Sandbox 的 Python SDK：

```bash
pip install aio-sandbox
```

#### 基本配置

导入并配置 Python 客户端：

```python
from aio_sandbox import AioClient
import asyncio

# 初始化客户端
client = AioClient(
    base_url="http://localhost:8080",  # AIO Sandbox URL
    timeout=30.0,  # 请求超时（秒）
    retries=3,     # 重试次数
    retry_delay=1.0  # 重试之间的延迟
)
```

#### Shell 操作

执行 Shell 命令并管理会话：

```python
async def shell_example():
    # 执行简单命令
    result = await client.shell.exec(command="ls -la")

    if result.success:
        print(f"输出：{result.data.output}")
        print(f"退出码：{result.data.exit_code}")

    # 使用会话管理执行
    session_id = "my-session-1"
    await client.shell.exec(
        command="cd /workspace && pwd",
        session_id=session_id
    )

    # 在同一会话中继续
    result = await client.shell.exec(
        command="ls",
        session_id=session_id
    )

    # 长时间运行任务的异步执行
    await client.shell.exec(
        command="python long_script.py",
        async_mode=True,
        session_id=session_id
    )

    # 查看会话输出
    view_result = await client.shell.view(session_id=session_id)
    print(view_result.data.output)

# 运行示例
asyncio.run(shell_example())
```

#### 文件操作

管理文件和目录：

```python
async def file_example():
    # 写入文件
    await client.file.write(
        file="/tmp/example.py",
        content="""
import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.plot(x, y)
plt.savefig('/tmp/plot.png')
print("图表已保存！")
        """.strip()
    )

    # 读取文件内容
    content = await client.file.read(file="/tmp/example.py")
    if content.success:
        print(f"文件内容：\n{content.data.content}")

    # 列出目录内容
    files = await client.file.list(
        path="/tmp",
        recursive=True,
        include_size=True
    )

    for file_info in files.data.files:
        print(f"{file_info.name}: {file_info.size} 字节")

    # 在文件中搜索
    search_result = await client.file.search(
        file="/tmp/example.py",
        regex=r"import \w+"
    )

    if search_result.success:
        for match in search_result.data.matches:
            print(f"第 {match.line} 行：{match.content}")

    # 按模式查找文件
    found_files = await client.file.find(
        path="/tmp",
        glob="*.py"
    )

asyncio.run(file_example())
```

#### 代码执行

安全地执行 Python 和 JavaScript 代码：

```python
async def code_execution_example():
    # 在 Jupyter 内核中执行 Python 代码
    jupyter_result = await client.jupyter.execute(
        code="""
import pandas as pd
import numpy as np

# 创建示例数据
df = pd.DataFrame({
    'x': np.random.randn(100),
    'y': np.random.randn(100)
})

print(f"DataFrame 形状：{df.shape}")
print(df.head())
        """,
        timeout=60,
        session_id="data-analysis-session"
    )

    if jupyter_result.success:
        print("Jupyter 输出：")
        for output in jupyter_result.data.outputs:
            if output.output_type == "stream":
                print(output.text)
            elif output.output_type == "execute_result":
                print(output.data.get("text/plain", ""))

    # 执行 Node.js 代码
    nodejs_result = await client.nodejs.execute(
        code="""
const fs = require('fs');
const path = require('path');

// 如果存在则读取 package.json
try {
    const packagePath = path.join(process.cwd(), 'package.json');
    if (fs.existsSync(packagePath)) {
        const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
        console.log(`项目：${pkg.name || '未知'}`);
        console.log(`版本：${pkg.version || '未知'}`);
    } else {
        console.log('未找到 package.json');
    }
} catch (error) {
    console.error('错误：', error.message);
}
        """,
        timeout=30
    )

    if nodejs_result.success:
        print(f"Node.js 输出：{nodejs_result.data.stdout}")

asyncio.run(code_execution_example())
```

#### MCP 集成

使用模型上下文协议服务：

```python
async def mcp_example():
    # 列出可用的 MCP 服务器
    servers = await client.mcp.list_servers()
    print("可用的 MCP 服务器：", servers.data)

    # 从特定服务器获取工具
    browser_tools = await client.mcp.list_tools(server_name="browser")

    for tool in browser_tools.data.tools:
        print(f"工具：{tool.name}")
        print(f"描述：{tool.description}")

    # 执行工具
    screenshot_result = await client.mcp.execute_tool(
        server_name="browser",
        tool_name="screenshot",
        arguments={
            "url": "https://example.com",
            "width": 1920,
            "height": 1080
        }
    )

    if screenshot_result.success:
        # 保存截图数据
        await client.file.write(
            file="/tmp/screenshot.png",
            content=screenshot_result.data.content[0].data,  # Base64 图像数据
            append=False
        )

asyncio.run(mcp_example())
```

#### 错误处理和最佳实践

```python
async def robust_example():
    try:
        # 始终使用上下文管理器进行资源清理
        async with AioClient("http://localhost:8080") as client:
            # 设置错误处理
            result = await client.shell.exec("potentially-failing-command")

            if not result.success:
                print(f"命令失败：{result.message}")
                if hasattr(result, 'error_code'):
                    print(f"错误代码：{result.error_code}")

            # 检查沙盒状态
            status = await client.sandbox.get_context()
            print(f"沙盒运行时间：{status.data.uptime}")
            print(f"可用包：{len(status.data.packages)}")

    except Exception as e:
        print(f"连接错误：{e}")

asyncio.run(robust_example())
```


### Node.js SDK

要安装 SDK，请使用以下命令：

```bash
npm install @agent-infra/sandbox
```


#### 基本配置

首先导入 SDK 并配置客户端：

```typescript
import { AioClient } from "@agent-infra/sandbox";

const client = new AioClient({
  baseUrl: `https://{aio.sandbox.example}`, // URL 和端口应与 Aio Sandbox 一致
  timeout: 30000, // 可选：请求超时（毫秒）
  retries: 3, // 可选：重试次数
  retryDelay: 1000, // 可选：重试之间的延迟（毫秒）
});
```

#### Shell 执行

在沙盒内执行 Shell 命令：

```typescript
const response = await client.shellExec({
  command: "ls -la",
});

if (response.success) {
  console.log("命令输出：", response.data.output);
} else {
  console.error("错误：", response.message);
}

// 异步轮询训练结果，适用于长期任务
const response = await client.shellExecWithPolling({
  command: "ls -la",
  maxWaitTime: 60 * 1000,
});
```

#### 文件管理

列出目录中的文件：

```typescript
const fileList = await client.fileList({
  path: "/home/gem",
  recursive: true,
});

if (fileList.success) {
  console.log("文件：", fileList.data.files);
} else {
  console.error("错误：", fileList.message);
}
```

#### Jupyter 代码执行

运行 Jupyter notebook 代码：

```typescript
const jupyterResponse = await client.jupyterExecute({
  code: "print('你好，Jupyter！')",
  kernel_name: "python3",
});

if (jupyterResponse.success) {
  console.log("输出：", jupyterResponse.data);
} else {
  console.error("错误：", jupyterResponse.message);
}
```

## 下一步

准备好实施这些模式了吗？选择您的路径：

- **[终端示例](/examples/terminal)** - 从终端集成开始
- **[浏览器示例](/examples/browser)** - 探索浏览器自动化
- **[Agent 集成](/examples/agent)** - 构建 AI 驱动的工作流

如需其他支持：
- 查看 [API 文档](/api/) 了解详细规范
- 探索 [GitHub 仓库](https://github.com/agent-infra/sandbox) 获取最新更新

---

### En Daemon Examples Index (`website/docs/en/daemon/examples/index.mdx`)

import { ApiV1, ApiV2, Tab, Tabs } from '@theme';

# Examples

Each example starts with a concrete task against a live `aiod` daemon, exercises one sandbox capability, and checks the result. The code is runnable as written.

## Conventions

`BASE_URL` and the API key follow [Quick Start](/daemon/start/quick-start). Every JSON response uses the envelope `{"success": bool, "message": str, "data": ..., "hint": null|str}`; validation failures answer `422` with a top-level `errors` list. See [Error Handling](/daemon/basic/error-handling).

Every example is written twice — a v2 form and a v1 form — and the API Preference switch in the sidebar picks which one you see. The v2 form calls the routes through the small `Aio` helper below; the v1 form uses the 1.x SDK (`agent_sandbox.Sandbox` in Python, `SandboxClient` from `@agent-infra/sandbox` in TypeScript), and falls back to the same helper on the `/v1` route for the few calls the SDK has no method for. Wherever the helper is used, the example starts with `sb = Aio(BASE_URL)`.

<Tabs groupId="sdk-lang">
<Tab label="Python">

```python
import httpx


class Aio:
    """Envelope-aware client for the v2 routes; raises on success=false."""

    def __init__(self, base_url, api_key=None, timeout=120):
        headers = {"x-api-key": api_key} if api_key else {}
        self.http = httpx.Client(base_url=base_url, headers=headers, timeout=timeout)

    def call(self, method, route, **kw):
        body = self.http.request(method, route, **kw).json()
        if not body.get("success"):
            raise RuntimeError(f"{method} {route}: {body.get('message')}")
        return body["data"]

    def get(self, route, **params):
        return self.call("GET", route, params=params)

    def post(self, route, **body):
        return self.call("POST", route, json=body)

    def delete(self, route, **params):
        return self.call("DELETE", route, params=params)
```

</Tab>
<Tab label="TypeScript">

```ts
export class Aio {
  constructor(private base: string, private key?: string) {}

  async call<T = any>(method: string, path: string, body?: unknown): Promise<T> {
    const r = await fetch(this.base + path, {
      method,
      headers: {
        "Content-Type": "application/json",
        ...(this.key ? { "x-api-key": this.key } : {}),
      },
      body: body === undefined ? undefined : JSON.stringify(body),
    });
    const env = await r.json();
    if (!env.success) throw new Error(`${method} ${path}: ${env.message}`);
    return env.data as T;
  }

  get<T = any>(path: string) { return this.call<T>("GET", path); }
  post<T = any>(path: string, body?: unknown) { return this.call<T>("POST", path, body); }
  delete<T = any>(path: string) { return this.call<T>("DELETE", path); }
}
```

</Tab>
</Tabs>

`sb.post("/v2/commands", command="wc -l /tmp/x")` posts a JSON body; `sb.get`/`sb.delete` take query params the same way — the first positional argument is `route`, so `sb.post("/v2/fs/read", path="/tmp/x")` works directly. Binary routes (download, screenshot) read `sb.http.get(...)` / `fetch` directly, bypassing the envelope check.

## First call

Confirm the daemon is up and read its capabilities:

```bash
curl "$BASE_URL/health"
```

<ApiV2>

```bash
curl "$BASE_URL/v2/sandbox" | python3 -m json.tool
```

</ApiV2>

<ApiV1>

```bash
curl "$BASE_URL/v1/capabilities" | python3 -m json.tool
```

</ApiV1>

A missing capability turns its own routes into `503`; the daemon still starts.

## All examples

| Example | Shows | Needs |
| --- | --- | --- |
| [Agent Calls the Sandbox](/daemon/examples/agent-call-sandbox) | Write a file, run a command, execute Python, read the result | `files`, `exec`, `code_interpreter` |
| [MCP](/daemon/examples/mcp) | The same task through one JSON-RPC endpoint, and how tool errors look | `exec`, `files`, `code_interpreter` |
| [Browser (CDP)](/daemon/examples/browser-cdp) | Playwright and Puppeteer against the sandbox's Chromium | `browser` |
| [Browser Use](/daemon/examples/browser-use) | Build a page in the sandbox, then fill it, click it, and check the result | `browser`, `files`, `exec` |
| [Interactive Terminal](/daemon/examples/terminal) | A live PTY over WebSocket from a minimal client | `exec` with `pty` |
| [Code Execution](/daemon/examples/code-execution) | A data-analysis session: CSV in, pandas, chart back as PNG | `code_interpreter` |
| [File Operations](/daemon/examples/file-ops) | Scaffold a project, search and edit it, watch it, and the error contract | `files` |
| [Computer Use](/daemon/examples/computer-use) | Navigate Chromium and follow a link through the accessibility tree | `computer` |

## One task, three ways

The four-step task on [Agent Calls the Sandbox](/daemon/examples/agent-call-sandbox) exists in three forms: the v2 routes, the 1.x SDK, and one JSON-RPC endpoint on [MCP](/daemon/examples/mcp). The steps, the file names and the result `27` are the same in all three; only the transport changes, so an agent can use whichever protocol its framework already speaks.

## SDK

Both SDKs target the v1 routes (Python `agent-sandbox`, TypeScript `@agent-infra/sandbox`):

<Tabs groupId="sdk-lang">
<Tab label="Python">

```python
from agent_sandbox import Sandbox

client = Sandbox(base_url="http://127.0.0.1:18091")
# headers={"x-api-key": "<key>"} when AIO_API_KEY is set
client.bash.exec(command="uname -a")
```

</Tab>
<Tab label="TypeScript">

```ts
import { SandboxClient } from "@agent-infra/sandbox";

const client = new SandboxClient({ environment: "http://127.0.0.1:18091" });
await client.bash.exec({ command: "uname -a" });
```

</Tab>
</Tabs>

Which calls work, which need a raw HTTP call, and which routes are gone: [1.x SDK compatibility](/daemon/start/migration#1x-sdk-compatibility). `/v2` is called through the HTTP API; see the [API Reference](/daemon/api).

---

### Zh Daemon Examples Index (`website/docs/zh/daemon/examples/index.mdx`)

import { ApiV1, ApiV2, Tab, Tabs } from '@theme';

# 示例

这些示例都围绕一个具体任务展开：从运行中的 `aiod` 开始，调用对应的沙箱能力并验证结果。每页聚焦一项能力，代码可以直接运行。

## 约定

`BASE_URL` 和 API key 的用法见 [快速开始](/zh/daemon/start/quick-start)。

所有 JSON 响应都使用统一的返回结构 `{"success": bool, "message": str, "data": ..., "hint": null|str}`。

校验失败返回 `422`，顶层带 `errors` 列表。详见 [错误处理](/zh/daemon/basic/error-handling)。

每个示例都提供 v2 和 v1 两种写法，侧栏的 API Preference 开关决定显示哪一种。

v2 使用下方的 `Aio` helper；v1 使用 1.x SDK。SDK 不支持的少数调用，也会通过 helper 发送到 `/v1`。使用 helper 的示例都以 `sb = Aio(BASE_URL)` 开头。

<Tabs groupId="sdk-lang">
<Tab label="Python">

```python
import httpx


class Aio:
    """Envelope-aware client for the v2 routes; raises on success=false."""

    def __init__(self, base_url, api_key=None, timeout=120):
        headers = {"x-api-key": api_key} if api_key else {}
        self.http = httpx.Client(base_url=base_url, headers=headers, timeout=timeout)

    def call(self, method, route, **kw):
        body = self.http.request(method, route, **kw).json()
        if not body.get("success"):
            raise RuntimeError(f"{method} {route}: {body.get('message')}")
        return body["data"]

    def get(self, route, **params):
        return self.call("GET", route, params=params)

    def post(self, route, **body):
        return self.call("POST", route, json=body)

    def delete(self, route, **params):
        return self.call("DELETE", route, params=params)
```

</Tab>
<Tab label="TypeScript">

```ts
export class Aio {
  constructor(private base: string, private key?: string) {}

  async call<T = any>(method: string, path: string, body?: unknown): Promise<T> {
    const r = await fetch(this.base + path, {
      method,
      headers: {
        "Content-Type": "application/json",
        ...(this.key ? { "x-api-key": this.key } : {}),
      },
      body: body === undefined ? undefined : JSON.stringify(body),
    });
    const env = await r.json();
    if (!env.success) throw new Error(`${method} ${path}: ${env.message}`);
    return env.data as T;
  }

  get<T = any>(path: string) { return this.call<T>("GET", path); }
  post<T = any>(path: string, body?: unknown) { return this.call<T>("POST", path, body); }
  delete<T = any>(path: string) { return this.call<T>("DELETE", path); }
}
```

</Tab>
</Tabs>

`sb.post("/v2/commands", command="wc -l /tmp/x")` 发送 JSON body；`sb.get` 和 `sb.delete` 同样接收查询参数。

第一个位置参数是 `route`，因此 `sb.post("/v2/fs/read", path="/tmp/x")` 可以直接这样调用。二进制路由（下载、截图）请使用 `sb.http.get(...)` 或 `fetch`，绕过返回结构校验。

## 第一次调用

确认 daemon 在运行，并读取它的能力：

```bash
curl "$BASE_URL/health"
```

<ApiV2>

```bash
curl "$BASE_URL/v2/sandbox" | python3 -m json.tool
```

</ApiV2>

<ApiV1>

```bash
curl "$BASE_URL/v1/capabilities" | python3 -m json.tool
```

</ApiV1>

缺少某项能力时，对应路由返回 `503`，但 daemon 仍然可以启动。

## 示例列表

| 示例 | 内容 | 所需能力 |
| --- | --- | --- |
| [Agent 调用沙箱](/zh/daemon/examples/agent-call-sandbox) | 写入文件、执行命令、执行 Python、读取结果 | `files`、`exec`、`code_interpreter` |
| [MCP 调用](/zh/daemon/examples/mcp) | 同样的任务走一个 JSON-RPC 端点，以及工具错误长什么样 | `exec`、`files`、`code_interpreter` |
| [浏览器（CDP）](/zh/daemon/examples/browser-cdp) | 用 Playwright 和 Puppeteer 驱动沙箱里的 Chromium | `browser` |
| [Browser Use](/zh/daemon/examples/browser-use) | 在沙箱里创建一个页面，再用 REST 填写、点击、校验结果 | `browser`、`files`、`exec` |
| [交互式终端](/zh/daemon/examples/terminal) | 用最小客户端通过 WebSocket 连接实时 PTY | `exec` 的 `pty` |
| [代码执行](/zh/daemon/examples/code-execution) | 一次数据分析会话：写入 CSV，pandas 计算，图表以 PNG 返回 | `code_interpreter` |
| [文件操作](/zh/daemon/examples/file-ops) | 创建项目、搜索与编辑、监听变更，以及错误处理 | `files` |
| [Computer Use](/zh/daemon/examples/computer-use) | 导航 Chromium，并通过无障碍树点击链接 | `computer` |

## 同一任务的三种调用方式

[Agent 调用沙箱](/zh/daemon/examples/agent-call-sandbox) 中的四步任务有三种写法：v2 路由、1.x SDK，以及 [MCP 调用](/zh/daemon/examples/mcp) 中的 JSON-RPC 端点。

三种写法的步骤、文件名和结果 `27` 都相同，区别只有传输方式。agent 可以选择框架已经支持的协议接入。

## SDK

两个 SDK 都对接 v1 路由（Python `agent-sandbox`、TypeScript `@agent-infra/sandbox`）：

<Tabs groupId="sdk-lang">
<Tab label="Python">

```python
from agent_sandbox import Sandbox

client = Sandbox(base_url="http://127.0.0.1:18091")
# headers={"x-api-key": "<key>"} when AIO_API_KEY is set
client.bash.exec(command="uname -a")
```

</Tab>
<Tab label="TypeScript">

```ts
import { SandboxClient } from "@agent-infra/sandbox";

const client = new SandboxClient({ environment: "http://127.0.0.1:18091" });
await client.bash.exec({ command: "uname -a" });
```

</Tab>
</Tabs>

哪些调用可用、哪些需要改用 HTTP、哪些路由已移除，见 [1.x SDK 兼容性](/zh/daemon/start/migration#1x-sdk-兼容性)。

`/v2` 通过 HTTP API 调用，参考 [API 参考](/zh/daemon/api)。

---

### En 404 (`website/docs/en/404.md`)

---
pageType: custom
layout: false
---

<div style="text-align: center; padding: 4rem 2rem; min-height: 80vh; display: flex; align-items: center; justify-content: center;">
  <div style="max-width: 700px; margin: 0 auto;">
    
    
    <div style="margin: 2rem 0;">
      <pre style="font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; font-size: 1.4rem; color: #e74c3c; margin: 0; text-shadow: 1px 1px 0 rgba(0,0,0,0.1);">
     ██╗  ██╗ ██████╗ ██╗  ██╗
     ██║  ██║██╔═══██╗██║  ██║
     ███████║██║   ██║███████║
     ╚════██║██║   ██║╚════██║
          ██║╚██████╔╝     ██║
          ╚═╝ ╚═════╝      ╚═╝
      </pre>
    </div>

    <h1 style="font-size: 2.8rem; margin: 1.5rem 0 0.5rem; color: #2c3e50; font-weight: 700;">
      Oops! Page Not Found
    </h1>

    <p style="font-size: 1.2rem; color: #7f8c8d; margin: 1rem 0 3rem; line-height: 1.6; max-width: 500px; margin-left: auto; margin-right: auto;">
      The page you're looking for seems to have escaped from the sandbox! 
      Let's get you back on track with these helpful links.
    </p>

    
    <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin: 3rem 0; max-width: 600px; margin-left: auto; margin-right: auto;">
      <a href="/sandbox/" 
         style="display: flex; align-items: center; justify-content: center; background: linear-gradient(135deg, #3498db, #2980b9); color: white; padding: 1rem 1.5rem; text-decoration: none; border-radius: 10px; font-weight: 600; transition: transform 0.2s; box-shadow: 0 4px 15px rgba(52, 152, 219, 0.3);"
         onmouseover="this.style.transform='translateY(-2px)'" 
         onmouseout="this.style.transform='translateY(0)'">
        <span style="font-size: 1.5rem; margin-right: 0.5rem;">🏠</span>
        Go Home
      </a>
      
      <a href="/sandbox/guide/" 
         style="display: flex; align-items: center; justify-content: center; background: linear-gradient(135deg, #2ecc71, #27ae60); color: white; padding: 1rem 1.5rem; text-decoration: none; border-radius: 10px; font-weight: 600; transition: transform 0.2s; box-shadow: 0 4px 15px rgba(46, 204, 113, 0.3);"
         onmouseover="this.style.transform='translateY(-2px)'" 
         onmouseout="this.style.transform='translateY(0)'">
        <span style="font-size: 1.5rem; margin-right: 0.5rem;">📖</span>
        Documentation
      </a>
      
      <a href="/sandbox/api/" 
         style="display: flex; align-items: center; justify-content: center; background: linear-gradient(135deg, #e67e22, #d35400); color: white; padding: 1rem 1.5rem; text-decoration: none; border-radius: 10px; font-weight: 600; transition: transform 0.2s; box-shadow: 0 4px 15px rgba(230, 126, 34, 0.3);"
         onmouseover="this.style.transform='translateY(-2px)'" 
         onmouseout="this.style.transform='translateY(0)'">
        <span style="font-size: 1.5rem; margin-right: 0.5rem;">🔧</span>
        API Reference
      </a>
    </div>

    
    <div style="background: linear-gradient(135deg, #f8f9fa, #e9ecef); border-radius: 15px; padding: 2.5rem; margin: 3rem 0; border: 1px solid #dee2e6; box-shadow: 0 8px 25px rgba(0,0,0,0.1);">
      <h3 style="margin-top: 0; margin-bottom: 1.5rem; color: #2c3e50; font-size: 1.3rem; font-weight: 600;">
        🔍 Popular Pages
      </h3>
      <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 1rem; text-align: left;">
        <div>
          <h4 style="color: #3498db; margin: 0 0 0.5rem; font-size: 1rem;">Getting Started</h4>
          <ul style="list-style: none; padding: 0; margin: 0;">
            <li style="margin: 0.3rem 0;">
              <a href="/sandbox/guide/quick-start" style="color: #555; text-decoration: none; font-size: 0.9rem; display: flex; align-items: center;">
                <span style="margin-right: 0.5rem;">⚡</span>Quick Start Guide
              </a>
            </li>
            <li style="margin: 0.3rem 0;">
              <a href="/sandbox/guide/features" style="color: #555; text-decoration: none; font-size: 0.9rem; display: flex; align-items: center;">
                <span style="margin-right: 0.5rem;">✨</span>Features Overview
              </a>
            </li>
          </ul>
        </div>
        <div>
          <h4 style="color: #e67e22; margin: 0 0 0.5rem; font-size: 1rem;">API Documentation</h4>
          <ul style="list-style: none; padding: 0; margin: 0;">
            <li style="margin: 0.3rem 0;">
              <a href="/sandbox/api/shell" style="color: #555; text-decoration: none; font-size: 0.9rem; display: flex; align-items: center;">
                <span style="margin-right: 0.5rem;">🐚</span>Shell WebSocket API
              </a>
            </li>
            <li style="margin: 0.3rem 0;">
              <a href="/sandbox/api/file" style="color: #555; text-decoration: none; font-size: 0.9rem; display: flex; align-items: center;">
                <span style="margin-right: 0.5rem;">📁</span>File Operations API
              </a>
            </li>
          </ul>
        </div>
      </div>
    </div>

    
    <div style="margin: 3rem 0;">
      <div style="position: relative; max-width: 400px; margin: 0 auto;">
        <input type="text" id="quickSearch" placeholder="🔍 Search documentation..." 
               style="width: 100%; padding: 1rem 1.5rem; border: 2px solid #e9ecef; border-radius: 25px; font-size: 1rem; outline: none; transition: border-color 0.3s;"
               onfocus="this.style.borderColor='#3498db'" 
               onblur="this.style.borderColor='#e9ecef'">
      </div>
      <p style="font-size: 0.85rem; color: #999; margin-top: 0.5rem;">
        Try searching for "terminal", "file operations", "browser", or "API"
      </p>
    </div>

    
    <div style="margin: 4rem 0; opacity: 0.6;">
      <h4 style="color: #666; margin-bottom: 1rem; font-size: 1rem;">AIO Sandbox Architecture</h4>
      <pre style="font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; font-size: 0.75rem; color: #666; line-height: 1.2; background: #f8f9fa; padding: 1rem; border-radius: 8px; overflow-x: auto; margin: 0;">
┌─────────────────────────────────────────────────────────────┐
│                    🌐 Browser + VNC                        │
├─────────────────────────────────────────────────────────────┤
│  💻 VSCode Server  │  🐚 Shell Terminal  │  📁 File Ops   │
├─────────────────────────────────────────────────────────────┤
│              🔗 MCP Hub + 🔒 Sandbox Fusion               │
├─────────────────────────────────────────────────────────────┤
│         🚀 Preview Proxy + 📊 Service Monitoring          │
└─────────────────────────────────────────────────────────────┘
      </pre>
    </div>

    
    <div style="border-top: 1px solid #e9ecef; padding-top: 2rem; margin-top: 3rem;">
      <p style="font-size: 0.9rem; color: #666; margin: 0;">
        Still can't find what you're looking for? 
        <a href="https://github.com/agent-infra/sandbox" style="color: #3498db; text-decoration: none; font-weight: 500;">Visit our GitHub</a> 
        or check the 
        <a href="/sandbox/examples/" style="color: #3498db; text-decoration: none; font-weight: 500;">examples section</a>.
      </p>
    </div>

  </div>
</div>

<script>
document.getElementById('quickSearch').addEventListener('input', function(e) {
  const query = e.target.value.toLowerCase();
  const suggestions = {
    'terminal': '/sandbox/api/shell',
    'shell': '/sandbox/api/shell',
    'file': '/sandbox/api/file',
    'browser': '/sandbox/guide/browser',
    'api': '/sandbox/api/',
    'quick': '/sandbox/guide/quick-start',
    'start': '/sandbox/guide/quick-start',
    'features': '/sandbox/guide/features',
    'mcp': '/sandbox/guide/mcp',
    'proxy': '/sandbox/guide/proxy',
    'security': '/sandbox/guide/security',
    'examples': '/sandbox/examples/'
  };
  
  if (e.key === 'Enter') {
    for (const [key, url] of Object.entries(suggestions)) {
      if (query.includes(key)) {
        window.location.href = url;
        return;
      }
    }
  }
});
</script>

---

### En  Nav.Json (`website/docs/en/_nav.json`)

[
  {
    "text": "Guide",
    "link": "/guide/start/introduction",
    "activeMatch": "/guide/"
  },
  {
    "text": "Daemon",
    "link": "/daemon/start/introduction",
    "activeMatch": "/daemon/"
  },
  {
    "text": "API",
    "link": "/api",
    "activeMatch": "/api/"
  },
  {
    "text": "Blog",
    "link": "/blog/index",
    "activeMatch": "/blog/"
  },
  {
    "text": "Version",
    "items": [
      {
        "text": "Changelog",
        "link": "https://github.com/agent-infra/sandbox/releases"
      }
    ]
  }
]

---

### Zh 404 (`website/docs/zh/404.md`)

---
pageType: custom
layout: false
---

<div style="text-align: center; padding: 4rem 2rem; min-height: 80vh; display: flex; align-items: center; justify-content: center;">
  <div style="max-width: 700px; margin: 0 auto;">

    
    <div style="margin: 2rem 0;">
      <pre style="font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; font-size: 1.4rem; color: #e74c3c; margin: 0; text-shadow: 1px 1px 0 rgba(0,0,0,0.1);">
     ██╗  ██╗ ██████╗ ██╗  ██╗
     ██║  ██║██╔═══██╗██║  ██║
     ███████║██║   ██║███████║
     ╚════██║██║   ██║╚════██║
          ██║╚██████╔╝     ██║
          ╚═╝ ╚═════╝      ╚═╝
      </pre>
    </div>

    <h1 style="font-size: 2.8rem; margin: 1.5rem 0 0.5rem; color: #2c3e50; font-weight: 700;">
      哎呀！页面未找到
    </h1>

    <p style="font-size: 1.2rem; color: #7f8c8d; margin: 1rem 0 3rem; line-height: 1.6; max-width: 500px; margin-left: auto; margin-right: auto;">
      您要查找的页面似乎已从沙盒中逃脱了！
      让我们通过这些有用的链接帮您回到正轨。
    </p>

    
    <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin: 3rem 0; max-width: 600px; margin-left: auto; margin-right: auto;">
      <a href="/sandbox/"
         style="display: flex; align-items: center; justify-content: center; background: linear-gradient(135deg, #3498db, #2980b9); color: white; padding: 1rem 1.5rem; text-decoration: none; border-radius: 10px; font-weight: 600; transition: transform 0.2s; box-shadow: 0 4px 15px rgba(52, 152, 219, 0.3);"
         onmouseover="this.style.transform='translateY(-2px)'"
         onmouseout="this.style.transform='translateY(0)'">
        <span style="font-size: 1.5rem; margin-right: 0.5rem;">🏠</span>
        返回首页
      </a>

      <a href="/sandbox/guide/"
         style="display: flex; align-items: center; justify-content: center; background: linear-gradient(135deg, #2ecc71, #27ae60); color: white; padding: 1rem 1.5rem; text-decoration: none; border-radius: 10px; font-weight: 600; transition: transform 0.2s; box-shadow: 0 4px 15px rgba(46, 204, 113, 0.3);"
         onmouseover="this.style.transform='translateY(-2px)'"
         onmouseout="this.style.transform='translateY(0)'">
        <span style="font-size: 1.5rem; margin-right: 0.5rem;">📖</span>
        文档
      </a>

      <a href="/sandbox/api/"
         style="display: flex; align-items: center; justify-content: center; background: linear-gradient(135deg, #e67e22, #d35400); color: white; padding: 1rem 1.5rem; text-decoration: none; border-radius: 10px; font-weight: 600; transition: transform 0.2s; box-shadow: 0 4px 15px rgba(230, 126, 34, 0.3);"
         onmouseover="this.style.transform='translateY(-2px)'"
         onmouseout="this.style.transform='translateY(0)'">
        <span style="font-size: 1.5rem; margin-right: 0.5rem;">🔧</span>
        API 参考
      </a>
    </div>

    
    <div style="background: linear-gradient(135deg, #f8f9fa, #e9ecef); border-radius: 15px; padding: 2.5rem; margin: 3rem 0; border: 1px solid #dee2e6; box-shadow: 0 8px 25px rgba(0,0,0,0.1);">
      <h3 style="margin-top: 0; margin-bottom: 1.5rem; color: #2c3e50; font-size: 1.3rem; font-weight: 600;">
        🔍 热门页面
      </h3>
      <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(250px, 1fr)); gap: 1rem; text-align: left;">
        <div>
          <h4 style="color: #3498db; margin: 0 0 0.5rem; font-size: 1rem;">入门指南</h4>
          <ul style="list-style: none; padding: 0; margin: 0;">
            <li style="margin: 0.3rem 0;">
              <a href="/sandbox/guide/quick-start" style="color: #555; text-decoration: none; font-size: 0.9rem; display: flex; align-items: center;">
                <span style="margin-right: 0.5rem;">⚡</span>快速开始指南
              </a>
            </li>
            <li style="margin: 0.3rem 0;">
              <a href="/sandbox/guide/features" style="color: #555; text-decoration: none; font-size: 0.9rem; display: flex; align-items: center;">
                <span style="margin-right: 0.5rem;">✨</span>功能概览
              </a>
            </li>
          </ul>
        </div>
        <div>
          <h4 style="color: #e67e22; margin: 0 0 0.5rem; font-size: 1rem;">API 文档</h4>
          <ul style="list-style: none; padding: 0; margin: 0;">
            <li style="margin: 0.3rem 0;">
              <a href="/sandbox/api/shell" style="color: #555; text-decoration: none; font-size: 0.9rem; display: flex; align-items: center;">
                <span style="margin-right: 0.5rem;">🐚</span>Shell WebSocket API
              </a>
            </li>
            <li style="margin: 0.3rem 0;">
              <a href="/sandbox/api/file" style="color: #555; text-decoration: none; font-size: 0.9rem; display: flex; align-items: center;">
                <span style="margin-right: 0.5rem;">📁</span>文件操作 API
              </a>
            </li>
          </ul>
        </div>
      </div>
    </div>

    
    <div style="margin: 3rem 0;">
      <div style="position: relative; max-width: 400px; margin: 0 auto;">
        <input type="text" id="quickSearch" placeholder="🔍 搜索文档..."
               style="width: 100%; padding: 1rem 1.5rem; border: 2px solid #e9ecef; border-radius: 25px; font-size: 1rem; outline: none; transition: border-color 0.3s;"
               onfocus="this.style.borderColor='#3498db'"
               onblur="this.style.borderColor='#e9ecef'">
      </div>
      <p style="font-size: 0.85rem; color: #999; margin-top: 0.5rem;">
        尝试搜索 "终端"、"文件操作"、"浏览器" 或 "API"
      </p>
    </div>

    
    <div style="margin: 4rem 0; opacity: 0.6;">
      <h4 style="color: #666; margin-bottom: 1rem; font-size: 1rem;">AIO Sandbox 架构</h4>
      <pre style="font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; font-size: 0.75rem; color: #666; line-height: 1.2; background: #f8f9fa; padding: 1rem; border-radius: 8px; overflow-x: auto; margin: 0;">
┌─────────────────────────────────────────────────────────────┐
│                    🌐 浏览器 + VNC                          │
├─────────────────────────────────────────────────────────────┤
│  💻 VSCode 服务器  │  🐚 Shell 终端  │  📁 文件操作       │
├─────────────────────────────────────────────────────────────┤
│              🔗 MCP 中心 + 🔒 沙盒融合                     │
├─────────────────────────────────────────────────────────────┤
│         🚀 预览 Agent + 📊 服务监控                          │
└─────────────────────────────────────────────────────────────┘
      </pre>
    </div>

    
    <div style="border-top: 1px solid #e9ecef; padding-top: 2rem; margin-top: 3rem;">
      <p style="font-size: 0.9rem; color: #666; margin: 0;">
        仍然找不到您要查找的内容？
        <a href="https://github.com/agent-infra/sandbox" style="color: #3498db; text-decoration: none; font-weight: 500;">访问我们的 GitHub</a>
        或查看
        <a href="/sandbox/examples/" style="color: #3498db; text-decoration: none; font-weight: 500;">示例部分</a>。
      </p>
    </div>

  </div>
</div>

<script>
document.getElementById('quickSearch').addEventListener('input', function(e) {
  const query = e.target.value.toLowerCase();
  const suggestions = {
    'terminal': '/sandbox/api/shell',
    'shell': '/sandbox/api/shell',
    'file': '/sandbox/api/file',
    'browser': '/sandbox/guide/browser',
    'api': '/sandbox/api/',
    'quick': '/sandbox/guide/quick-start',
    'start': '/sandbox/guide/quick-start',
    'features': '/sandbox/guide/features',
    'mcp': '/sandbox/guide/mcp',
    'proxy': '/sandbox/guide/proxy',
    'security': '/sandbox/guide/security',
    'examples': '/sandbox/examples/',
    '终端': '/sandbox/api/shell',
    '文件': '/sandbox/api/file',
    '浏览器': '/sandbox/guide/browser',
    '快速': '/sandbox/guide/quick-start',
    '开始': '/sandbox/guide/quick-start',
    '功能': '/sandbox/guide/features',
    'Agent': '/sandbox/guide/proxy',
    '安全': '/sandbox/guide/security',
    '示例': '/sandbox/examples/'
  };

  if (e.key === 'Enter') {
    for (const [key, url] of Object.entries(suggestions)) {
      if (query.includes(key)) {
        window.location.href = url;
        return;
      }
    }
  }
});
</script>

---

### Zh  Nav.Json (`website/docs/zh/_nav.json`)

[
  {
    "text": "指南",
    "link": "/guide/start/introduction",
    "activeMatch": "/guide/"
  },
  {
    "text": "Daemon",
    "link": "/daemon/start/introduction",
    "activeMatch": "/daemon/"
  },
  {
    "text": "API",
    "link": "/api",
    "activeMatch": "/api/"
  },
  {
    "text": "博客",
    "link": "/blog/index",
    "activeMatch": "/blog/"
  },
  {
    "text": "版本",
    "items": [
      {
        "text": "更新日志",
        "link": "https://github.com/agent-infra/sandbox/releases"
      }
    ]
  }
]

---

### En Blog Announcing 0 (`website/docs/en/blog/announcing-0.mdx`)

---
date: 2025-10-29 14:00:00
sidebar: false
---

_October 29, 2025_

# AIO Sandbox: An Integrated and Customizable Sandbox Environment for AI Agents

## Background

As LLMs continue to evolve, AI application forms have undergone three generational shifts:

- **Chatbot**: Conversational interaction, answering questions
- **Copilot**: Collaborative assistance, improving efficiency
- **Agent**: Autonomous execution, completing tasks

Agents can autonomously perceive their environment, plan steps, and invoke tools, enabling them to **operate computers like humans**: automatically browsing web pages to collect information, generating and running code to analyze data, executing system commands to manage files, and even completing complex multi-step operations through visual interfaces. This capability allows Agent deliverables to approach or even exceed human professional standards.

<img src="/images/blog/announcing-0/0.png" width="600" />

### Pain Points

1. **🧩 Environment Fragmentation**: Multiple single-function sandboxes (like E2B for code execution, Browserbase for browsers) force Agents to transfer data across sandboxes via NAS/OSS, increasing latency and complexity. For example: a deep research Agent completing 'convert a paper into a PPT' needs to exchange dozens of intermediate files (JSON configs, chart images, preview screenshots, etc.) across multiple sandboxes, adding complexity and overhead to the entire Agent system.




2. **🎁 Difficult Customization**: Different types of Agents require different pre-installed tech stacks. Traditional sandboxes provide unified pre-installed environments that cannot meet all Agents' personalized needs.




3. 🔒 **Security Isolation Challenges:** Need to give Agents real system capabilities (network, files, browser, GPU) while maintaining strong isolation to prevent unauthorized access and data leaks.
4. 🖥️ **Difficult Visual Interaction:** Complex Agent tasks require human takeover, functional sandboxes need to integrate VNC, Terminal, VSCode to maintain consistent experience. Resolution switching, screenshots, and GUI visual operations.
5. **🌐 Browser Environment Complexity**: Anti-automation and fingerprint risk control, CDP instability, inadequate proxy support with username/password, missing GUI operations.

> A well-configured computer can significantly improve human work efficiency; similarly, a powerful sandbox environment can also improve Agent task quality and execution speed.



## Introduction

One-sentence introduction: AIO Sandbox integrates **browser**, **code execution**, **terminal**, **visual takeover**, **forward and reverse proxy**, **MCP**, **authentication** and other basic functions **in a single sandbox**, allowing **environment customization** based on needs, enabling different Agents to "complete tasks more efficiently in a unified environment container".



- Website: [sandbox.agent-infra.com](https://sandbox.agent-infra.com/)

- Github: [github.com/agent-infra/sandbox](https://github.com/agent-infra/sandbox)

- API: [sandbox.agent-infra.com/api](https://sandbox.agent-infra.com/api/)

- Paper: [arxiv.org/pdf/2509.02544#S2.SS2](https://arxiv.org/pdf/2509.02544)






### Features

- **📦 Out-of-the-box**: Connect directly to sandbox capabilities via `/mcp` protocol, also providing **API** / **SDK** for customizing sandbox toolsets.
- **🚀 Second-level Startup**: Full sandbox service startup completes in seconds, reaching millisecond-level after pre-caching/cold start.
- **🌈 Customizable**: Agents in various vertical scenarios need domain-specific tools and dependencies; AIO provides a unified image base, supporting **on-demand expansion** with convention-based routing and service configuration.
- **🌐 Browser**: Integrates Web Infra's RS lightweight kernel, providing CDP, screenshots, pure visual GUI operations, and Proxy configuration.
- **🔄 Human Takeover**: Provides browser VNC, Code Server, Terminal, supporting **human takeover** and debugging mid-task.
- **📡 Proxy and Forwarding**: Supports forward proxy with authentication; maps `{port}-{domain}` wildcard domains or `/proxy|/absproxy/{port}` paths to services inside the sandbox (convenient for preview/demo).
- **🔒Security Authentication**: JWT Bearer access control; provides Short-Lived Tickets for links that cannot carry Headers.

<div align="center">
  <img src="/images/blog/announcing-0/5.png" width="200" />
</div>

## Examples

| Instruction | Replay | Screenshot |
| :-- | :-- | :-- |
|Help me design an interesting website to introduce sauropod dinosaurs from the Jurassic and Cretaceous periods for elementary school children. I want the website to be cartoon-styled.|[Replay](https://lf3-static.bytednsdoc.com/obj/eden-cn/zyha-aulnh/ljhwZthlaukjlkulzlp/shared-conversations/agent-replay-UcZQrqbkmXyPWlMhWOT5b-1760518911224.html?replay=1)||
|Search for news about ByteDance's Seed 1.6 model, then write a modern-styled webpage and deploy it|[Replay](https://lf3-static.bytednsdoc.com/obj/eden-cn/zyha-aulnh/ljhwZthlaukjlkulzlp/shared-conversations/agent-tars-SiumVAbquVRmeNqDjrrT9-1756832121376.html?logo=agent-tars&replay=1)||
|Based on this OSWorld image, please search for the latest information on the internet and design a modern website for it.|[Replay](https://lf3-static.bytednsdoc.com/obj/eden-cn/zyha-aulnh/ljhwZthlaukjlkulzlp/shared-conversations/agent-tars-4TeM9bFCF1CqujHuEvED2-1757159422304.html?replay=1)||
|Play Poki 2048 game|[Replay](https://lf3-static.bytednsdoc.com/obj/eden-cn/zyha-aulnh/ljhwZthlaukjlkulzlp/shared-conversations/agent-replay-UoeDuQrv6mNv-jRfZFIdD-1760000200212.html?replay=1)||

> More at: https://seed-tars.com/showcase/ui-tars-2



## Quick Start

### Cloud

[One-Click Deploy All-in-One Sandbox Application--Function Service-Volcano Engine](https://www.volcengine.com/docs/6662/1851199)





### Local

Prerequisites: Install [Docker](https://www.docker.com/get-started/), then start locally with one command:

```bash
docker run --rm -it -p 127.0.0.1:8080:8080 ghcr.io/agent-infra/sandbox:latest

# For faster access in China
# docker run --security-opt seccomp=unconfined --rm -it -p 127.0.0.1:8080:8080 enterprise-public-cn-beijing.cr.volces.com/vefaas-public/all-in-one-sandbox:latest
```



## **System Architecture**

### Overview

AIO Sandbox provides Agents with basic capabilities like Browser, File, Shell, Code, and offers **extensibility** to support developers in combining and **customizing dedicated sandboxes** based on Agent needs (such as `AIO Sandbox for Mobile/Medical/Legal/Finance/Scientific Research`).
Sandbox customization levels increase progressively:

1. **Standard (Out-of-the-box)**: Plug-and-play for Agents via `/mcp` endpoint, suitable for quick PoC Agent validation.
2. **Custom Toolset (Tool/Skills Extension)**: Without modifying the image, add or orchestrate tools based on SDK/API (such as adding `web_search`); also extend Skills to implement automated handling of specific sandbox tasks.
3. **Custom Image**: Based on `FROM aio.sandbox` base image, install specific dependencies (such as multimedia/image processing, etc.), mount custom services (e.g., `/custom_tools/ocr` image recognition).




### Core Components




#### Browser

Browser environment for Agents, core is providing **CDP** and VNC, mainstream Browser Use frameworks can be used directly;
AIO provides x11-based browser GUI visual operation interface, which can be combined with CDP for more efficient, lower risk-control Browser Use solutions.





##### CDP

CDP (Chrome Devtools Protocol) is a protocol for communicating with Chrome or Chromium browsers, providing browser control APIs via WebSocket for navigation and loading, DOM manipulation, JS execution/debugging, network interception and simulation, screenshots and rendering, security and permissions, etc.
For a more intuitive understanding, here's an example of using CDP to initiate a page navigation command:

```Bash
'/Applications/Google Chrome.app/Contents/MacOS/Google Chrome' \
    --disable-gpu \
    --user-data-dir=./test \
    --remote-debugging-port=9222 \
    https://www.chromestatus.com
```

Visit `http://localhost:9222/json/version`, where `webSocketDebuggerUrl` is the CDP address:

```Bash
$ curl http://localhost:9222/json/version
{
   "Browser": "Chrome/141.0.7390.66",
   "Protocol-Version": "1.3",
   "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
   "V8-Version": "14.1.146.11",
   "WebKit-Version": "537.36 (@95681a3c3d516c397b75ff45b8980c1088666775)",
   "webSocketDebuggerUrl": "ws://localhost:9222/devtools/browser/a6c5f19f-5d24-4bed-ba08-9c15cf5aeedb"
}
```

After establishing a WebSocket connection with CDP, you can execute browser commands:



> Note: AIO Sandbox doesn't directly expose the CDP interface `/json/version`, but relays CDP through the uvicorn service and adds heartbeat detection to avoid ws disconnection issues.



##### GUI Visual Operations

**Screenshots**
Unlike CDP-based screenshots, visual screenshots `/v1/browser/screenshot` include Tabs (the entire browser window), and operations target the entire browser window.

| GUI Browser Screenshot (Tabs) | CDP-based Page Screenshot (Page) |
| :--: | :--: |
|  |  |


Unlike CDP browser operations, visual operations `/v1/browser/actions` **simulate human behavior** for clicking, typing, scrolling, etc., which can reduce target website risk control strategies.

**Unified Action Space**
Abstract GUI operations into composable minimal atomic actions, such as moving mouse, clicking, dragging, scrolling, key press, text input, and additional utility functions like wait, aligning as closely as possible with VLM visual models executing actual actions.

| action\_type | Description | Required Parameters | Optional Parameters |
| --- | --- | --- | --- |
| `MOVE_TO` | Move mouse to specified position | `x`, `y` | \- |
| `MOVE_REL` | Move relative to current mouse position | `x_offset`, `y_offset` | \- |
| `CLICK` | Click operation | \- | `x`, `y`, `button`, `num_clicks` |
| `MOUSE_DOWN` | Press mouse button | \- | `button` |
| `MOUSE_UP` | Release mouse button | \- | `button` |
| `RIGHT_CLICK` | Right click | \- | `x`, `y` |
| `DOUBLE_CLICK` | Double click | \- | `x`, `y` |
| `DRAG_TO` | Drag to specified position | `x`, `y` | \- |
| `DRAG_REL` | Drag relative to current mouse position | `x_offset`, `y_offset` | \- |
| `SCROLL` | Scroll operation | \- | `dx`, `dy` |
| `TYPING` | Type text | `text` | \- |
| `PRESS` | Press key | `key` | \- |
| `KEY_DOWN` | Press keyboard key | `key` | \- |
| `KEY_UP` | Release keyboard key | `key` | \- |
| `HOTKEY` | Key combination | `keys` (array), e.g.: `["ctrl", "c"]` | \- |
| `WAIT` | Wait | `duration` time (seconds s) | \- |



##### Takeover

When Browser Use encounters login requirements, human takeover is generally needed, requiring an interactive browser interface. Currently there are two approaches:

1. VNC Takeover: AIO Sandbox provides `/vnc/index.html` page for direct user interaction.



2. Frontend connects via CDP, real-time redrawing complete browser interface on Canvas ([Playground](https://browser-canvas-render.gf.bytedance.net/)); we've packaged the frontend part into a component [@agent-infra/browser-ui](https://www.npmjs.com/package/browser-ui). Below, left is the actual browser, right is browser-ui screen mirroring:






The differences between the two takeover methods are roughly as follows:

| **Comparison Dimension**   | **VNC**                        | **Canvas + CDP** (Chrome DevTools Protocol)          |
| -------------- | ------------------------------ | ----------------------------------------------------- |
| **Technical Principle**   | Remote desktop protocol, transmits entire screen pixels | Controls browser via CDP, Canvas renders content                  |
| **Transport Protocol**   | RFB (Remote Framebuffer)       | WebSocket + CDP                                       |
| **Transport Content**   | Complete browser view (with Tabs)      | Only browser current page content (no Tabs by default, can be implemented separately) |
| **Bandwidth Usage**   | High (10-50 Mbps)               | Low (1-5 Mbps)                                        |
| **Latency**       | Higher (50-200ms)               | Lower (10-50ms)                                       |
| **Stability**     | Not easily disconnected                       | Easily disconnected, needs manual heartbeat with CDP to avoid disconnection             |
| **CPU Usage**    | High (desktop encoding)                 | Low (browser rendering only)                                    |
| **Memory Usage**   | High (needs complete desktop environment)         | Low (browser process only)                                    |
| **Control Range**   | Entire browser                     | Browser internal pages only                                      |
| **Automation Capability** | Basic (mouse keyboard simulation)           | Powerful (DOM operations, network interception, JS injection, etc.)                   |
| **Multi-window Support** | ✅ Supported                         | ❌ Single browser window only                                    |
| **File Operations**   | ✅ Can operate local files             | ❌ Limited by browser sandbox                                    |



#### Command Line Interpreter

For Coding Agents, most tasks can be completed through command line execution. When designing the Shell module, using OpenHands' [CmdRunAction](https://github.com/All-Hands-AI/OpenHands/blob/2bbe15a329e35f5156cdafcbe63c3fd54978ff98/openhands/runtime/utils/bash.py#L494-L681) as the execution engine, combined with tmux, implements multi-session execution capability.




#### File Operations

File/code editing only requires two tools:

- **File CRUD**: Encapsulates basic I/O for file read/write/list directory/create/upload/download, with path validation and permission control, covering common file operation scenarios.

- **Text Editor**: Implements model-oriented fine-grained editing tool [str\_replace\_editor](https://docs.claude.com/zh-CN/docs/agents-and-tools/tool-use/text-editor-tool), supporting:
	- `view` (view file or directory, including line range)
	- `str_replace` (exact string replacement)
	- `insert` (insert by line, legacy version support)
	- `undo_edit` (undo)





#### Code Execution

Balancing language coverage and image size, using **Python** **3.10/3.11/3.12** and **Node.js** **22** runtimes from [Sandbox Fusion](https://bytedance.github.io/SandboxFusion/), providing an integrated secure isolation environment for code execution.





### MCP Servers Aggregator

Aggregates multiple MCP Servers (e.g., [chrome-devtools-mcp](https://github.com/ChromeDevTools/chrome-devtools-mcp)) through unified entry point `/mcp`, supporting **parameter-level filtering**, and allowing **tool name prefixing** (namespacing).



Filter MCP Servers by `search`, future expansion will include tags (`tags`) and category (`category`) multi-dimensional filtering to reduce redundant calls and lower model token costs.




### Proxy

In Agent sandboxes, there are generally two types of scenarios corresponding to forward and reverse proxies:

1. **Forward Proxy**: Browser Use Agent can access private/global networks

2. **Reverse Proxy**: Coding Agent services developed inside the sandbox are exposed externally for user-side preview




#### Forward Proxy

Using TinyProxy proxy server to bypass geographic restrictions, access restricted content, or provide secure access within corporate intranets.



Why introduce TinyProxy when Chrome has `--proxy-server` to specify proxy?
The [Chromium official documentation](https://chromium.googlesource.com/chromium/src/%2B/HEAD/net/docs/proxy.md#proxy-credentials-in-manual-proxy-settings) states that it will not use any username/password embedded in proxy settings (e.g., `http://user:pass@host:port`), authentication must go through a separate challenge dialog, affecting the entire Browser Use experience (as shown below):




#### Reverse Proxy


Provides two methods to access service ports inside the Sandbox:

1. **subdomain wildcard forwarding (recommended)**: Any domain matching `${port}-${domain}` format will be forwarded to ports inside the sandbox.

	

2. **subpath forwarding**: Encounters many issues: for routing-sensitive services (like frontend projects), the additional `/proxy|absproxy/${port}` path causes resource matching 404s.




### Authentication

Agent operations in the sandbox generate user data. To implement unified AIO Sandbox authentication without intrusion, without modifying any existing business routing configuration, and without increasing the mental burden of future routing configuration expansion, an **"asymmetric encryption + JWT"** reverse proxy architecture was designed at the internal Nginx gateway layer:





#### How to Enable (One-time Configuration)

- Generate key pair


```Shell
openssl genrsa -out private_key.pem 2048
openssl rsa -in private_key.pem -pubout -out public_key.pem
echo "Key pair generation complete!"
```

- Start service (with public key to enable authentication), using environment variable `JWT_PUBLIC_KEY`


```Shell
export JWT_PUBLIC_KEY=$(cat public_key.pem | base64)
JWT_PUBLIC_KEY="${JWT_PUBLIC_KEY}"
```



#### Issue JWT

Business service uses private key to generate a JWT valid for 1 hour. Below is a simplified script to generate JWT, in practice business backend should use mature JWT libraries:

```Shell
# This is a simplified script to generate JWT, in practice business backend should use mature JWT libraries
base64url_encode() { openssl base64 -e -A | tr '+/' '-_' | tr -d '='; }
header='{"alg":"RS256","typ":"JWT"}'
exp_time=$(($(date +%s) + 3600))
payload="{\"exp\":${exp_time}}"
to_be_signed="$(echo -n "$header" | base64url_encode).$(echo -n "$payload" | base64url_encode)"
signature=$(echo -n "$to_be_signed" | openssl dgst -sha256 -sign private_key.pem | base64url_encode)
jwt="${to_be_signed}.${signature}"
echo "JWT generated: ${jwt}"
```



#### Usage

1. Header Authentication

	```Shell
	curl --silent -X GET "http://localhost:8080/v1/sandbox" \
	     -H "Authorization: Bearer ${jwt}"
	```

2. Short-Lived Ticket Authentication Example (using VNC page access): Direct access **cannot authenticate via Header method**, can only use `?ticket=` ticket as query parameter.
	- Use JWT to obtain ticket from common endpoint (default validity is 30s, can be configured via `TICKET_TTL_SECONDS` environment variable)

	```Bash
	echo "Using JWT to exchange for common one-time ticket..."

	ticket_response=$(curl --silent -X POST "http://localhost:8080/tickets" \
	     -H "Authorization: Bearer ${jwt}")

	ticket=$(echo "$ticket_response" | jq -r .ticket)
	expires=$(echo "$ticket_response" | jq -r .expires_in)

	echo "Successfully obtained! Ticket: ${ticket}, Validity: ${expires} seconds"
	```

	- Client builds and uses VNC URL: Now you can use the obtained `${ticket}` variable to build the VNC URL and initiate access.

	```Bash
	# Bash script simulates client URL concatenation
	vnc_url="http://localhost:8080/vnc/index.html?ticket=${ticket}&path=websockify%3Fticket%3D${ticket}"

	echo "Client-built final URL: ${vnc_url}"

	# Simulate access (should be done in browser)
	# curl -I "${vnc_url}"
	```


## Extension and Ecosystem

### Custom Images

In AIO, service processes (supervisord) and service routing (Nginx) are automatically mounted following convention-based directories:

- Service process directory: `/opt/gem/supervisord/*.conf`
- Routing directory: `/opt/gem/nginx/*.conf`


To customize services and routing on top of the AIO image, refer to the following image code:

```Dockerfile
FROM enterprise-public-cn-beijing.cr.volces.com/vefaas-public/all-in-one-sandbox:latest

# ----------------------
# Install additional system dependencies (if any)
# installed path: /usr/bin/*
# ----------------------
RUN set -eux; \
    apt-get update; \
    apt-get install -y --no-install-recommends \
        ${your_system_dep} \
        --no-install-recommends; \
    # clean up
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*;

# ----------------------
# npm install (if any)
#
# ----------------------
RUN npm i ${your_npm_package}

# ----------------------
# python pip install (if any)
# installed path: /usr/local/bin/*
# ----------------------
RUN pip install ${your_python_package}

# Add custom Server service
COPY ./supervisord.agent_server.conf /opt/tiger/run/supervisord/agent_server.conf
# Bind Nginx routing
COPY ./nginx.agent_server.conf /opt/gem/nginx/nginx.agent_server.conf

# # If you don't need services in AIO, you can delete them, e.g., Code Server
# ## Delete Code Server process and routing
# RUN rm -rf /opt/gem/supervisord/supervisord.code_server.conf
# ## Delete Code Server routing
# RUN rm -rf /opt/gem/nginx/code_server.conf
```


### SDK Integration

Using [fern](https://buildwithfern.com/learn/sdks/overview/introduction) to convert AIO Sandbox API documentation directly into Python / Go / Node.js SDKs. Using Python as an example, a few lines of code connect AIO Sandbox's core functionality:

```Python
from agent_sandbox import Sandbox

client = Sandbox(base_url="http://localhost:8080")

# Execute Shell
shell_res = client.shell.exec_command(command="ls -la")
print(shell_res.data.output) # /home/gem

# Browser Screenshot
screenshot = client.browser.screenshot()
print(screenshot)

# Get Browser CDP
browser_info = client.browser.get_browser_info()
cdp_url = browser_info.data.cdp_url # ws://

# Read File
file_res = client.file.read_file(file="/home/gem/.bashrc")
print(file_res.data.content)
```

> More usage examples: [agent-infra/sandbox#examples](https://github.com/agent-infra/sandbox/tree/62e910bae02239f69f749b16a1a78d8deb30c533/examples)



#### browser-use

Just add 4 lines of code to integrate the community's [browser-use](https://github.com/browser-use/browser-use):



> Complete code: [browser-use#main.py](https://github.com/agent-infra/sandbox/blob/b950470e6d70eabf9941b9a98a0affd15dd2e86c/sdk/python/examples/browser-use-integration/main.py)



#### LangGraph-DeepAgents



> Complete code: [langgraph-deepagents#main.py](https://github.com/agent-infra/sandbox/blob/b950470e6d70eabf9941b9a98a0affd15dd2e86c/sdk/python/examples/langgraph-deepagents/main.py)



### Custom Toolsets

You can use API / SDK to compose high-level toolsets needed by Agents, for example `link_reader` returns page content for a URL:

```Python
from openai import OpenAI
from agent_sandbox import Sandbox
import json

client = OpenAI(
    api_key="your_api_key",
)
sandbox = Sandbox(base_url="http://localhost:8080")

tools = [{
    "type": "function",
    "function": {
        "name": "link_reader",
        "description": "Render and read webpage, return title, body text, and final URL (based on CDP).",
        "parameters": {
            "type": "object",
            "properties": {
                "url": {"type": "string", "format": "uri"},
                "timeout_ms": {"type": "integer", "default": 30000}
            },
            "required": ["url"]
        }
    }
}]

async def link_reader(url: str, timeout_ms: int = 30_000) -> dict:
    cdp_url = sandbox.browser.get_browser_info().cdp_url
    async with async_playwright() as p:
        browser = await p.chromium.connect_over_cdp(cdp_url)
        try:
            page = await browser.new_page()
            await page.goto(url, wait_until="networkidle", timeout=timeout_ms)
            title = await page.title()
            text = await page.evaluate("document.body.innerText || ''")
            return {"final_url": page.url, "title": title, "text": text[:8000]}
        finally:
            await browser.close()
```



### Deployment

Currently the best public cloud deployment form is function computing, based on Sandbox's designated instance access capability: [One-Click Deploy All-in-One Sandbox Application--Function Service-Volcano Engine](https://www.volcengine.com/docs/6662/1851199)





## Summary and Outlook

AIO Sandbox provides an **integrated**, **customizable** base environment (Agent Env), enabling Agents to complete diverse tasks including browsing, executing code, running commands, and file operations within the same environment, while supporting customization of domain-specific sandboxes for different Agents. This sandbox system will continue to evolve and expand alongside the rising intelligence ceiling of Agents and the creativity of developers.

Going forward, we will continue to refine **stability**, **observability**, and **ecosystem integration**, continuously improve evaluation systems and best practices, driving robust deployment and efficient operation of AIO Sandbox in more large-scale, high-demand Agent application scenarios.




## Appendix

### Terminology

| Term | Explanation |
| :-- | :-- |
| ***Agent*** | In the LLM context, an AI Agent is an intelligent entity that can autonomously understand intent, plan decisions, and execute complex tasks. An Agent is not an upgraded version of ChatGPT; it doesn't just tell you "how to do it," but actually helps you do it. If Copilot is the co-pilot, then Agent is the main driver. Similar to the human process of "doing things," an Agent's core functions can be summarized as a loop of three steps: Perception, Planning, and Action. |
| ***Copilot*** | Copilot refers to an AI-based assistance tool, typically integrated with specific software or applications, designed to help users improve work efficiency. Copilot systems analyze user behavior, inputs, data, and history to provide real-time suggestions, automate tasks, or enhance functionality, helping users make decisions or simplify operations. |
| ***AIO*** | All-In-One, refers to integrating multiple capabilities (Browser, Code Execution, Shell, File, visual takeover, authentication, proxy, etc.) within a **single image/instance**, reducing cross-environment switching and data transfer. |
| ***Sandbox*** | A controlled, isolated execution environment. Used to run browsers, code, or command lines, controlling resources and permissions, reducing impact and risk to the host system. |
| ***CDP*** | CDP (Chrome Devtools Protocol) is a protocol for communicating with Chrome or Chromium browsers. It allows developers to interact with browsers by sending commands and receiving events for debugging, analysis, and automated browser operations. CDP provides a set of APIs (Application Programming Interface) defining browser behavior and functionality. |
| ***VNC*** | VNC is a suite of "remote desktop sharing/control" technologies and tools based on the RFB (Remote Framebuffer) protocol. Core idea: encode the remote host's screen framebuffer (pixels) and transmit over network to the client, while replaying client keyboard and mouse events to the remote host, enabling cross-platform remote operation. |
| ***MCP*** | Model Context Protocol is an open protocol that standardizes how applications provide context to LLMs. Think of MCP as the USB-C port for AI applications. Just like USB-C provides a standard way for your devices to connect to various peripherals and accessories, MCP provides a standard way for your AI models to connect to different data sources and tools. |
| ***Browser Use*** | General term for Agents completing tasks like search, login, clicking, form filling, downloading through browsers, either via CDP commands or GUI visual operations. |
| ***OpenHands*** | OpenHands is an open-source AI Software Developer Agent Platform for training, evaluating, and running large language models (LLM) that can "autonomously program" in real development environments. It was initially released as OpenDevin, later renamed to OpenHands, maintained by the All Hands AI community. |



### References

- [UI-TARS-2 Technical Report: Advancing GUI Agent with Multi-Turn Reinforcement Learning](https://arxiv.org/pdf/2509.02544)
- [AIO Sandbox: All-in-One Sandbox for AI Agents & Developers](https://medium.com/coding-nexus/aio-sandbox-all-in-one-sandbox-for-ai-agents-developers-b0a5ca4cf2a8)
- [Agentic AI Infrastructure Practice Series (2): Necessity and Practice of Dedicated Sandbox Environment](https://aws.amazon.com/cn/blogs/china/agentic-ai-sandbox-practice/)
- [Writing effective tools for AI agents—using AI agents](https://www.anthropic.com/engineering/writing-tools-for-agents)
- [Unifying the Computer Use Action Space](https://scrapybara.com/blog/unified-action-space)

---

### En Daemon  Meta.Json (`website/docs/en/daemon/_meta.json`)

[
  {
    "type": "dir",
    "label": "Getting Started",
    "name": "start"
  },
  "architecture",
  {
    "type": "dir",
    "label": "Capabilities",
    "name": "basic"
  },
  {
    "type": "dir",
    "label": "Deploy",
    "name": "ops"
  },
  {
    "type": "dir",
    "label": "Examples",
    "name": "examples"
  },
  {
    "type": "file",
    "name": "api",
    "label": "API Reference"
  }
]

---

### En Daemon Architecture (`website/docs/en/daemon/architecture.md`)

# Architecture

`aiod` is AIO Sandbox's core daemon process. It serves the sandbox tools API and hosts the MCP endpoint.

The shell, interpreters, browser, and desktop it drives are separate processes. aiod discovers them at runtime but does not start them.

## The daemon process

It serves commands, files, terminals (PTY), code execution, and browser control over HTTP and WebSocket, and hosts `POST /mcp`.



The browser is the Chromium process listening for CDP at `BROWSER_REMOTE_DEBUGGING_HOST:PORT` (default `127.0.0.1:9222`); any process may start it.

The desktop is provided by the `computer-use` worker at `AIO_COMPUTER_USE_URL` (default `http://127.0.0.1:18100`). aiod only forwards `/v2/computer/*` to it and never touches a display itself. The worker is separate because it needs a desktop session.

On Windows the difference is explicit: aiod can run as a Session 0 service, but computer-use must run in the interactive logon session (see [Windows](/daemon/basic/windows)).

## Dependencies and capabilities

aiod always starts. At boot and on each capability check, it probes the dependencies and reports the result in `capabilities`:



| Dependency | Probe | Routes it enables |
| --- | --- | --- |
| Shell | `bash` on `PATH`; PowerShell on Windows | `/v2/commands`, `/v2/pty`, and the v1 forms |
| Interpreters | `python3`, `node` on `PATH`, or `AIO_JUPYTER_ENDPOINT` | `/v2/code`, `/v1/code`, `/v1/jupyter`, `/v1/nodejs` |
| Browser | CDP `GET /json/version` on the debugging port | `/v2/browser`, `/v1/browser` |
| Desktop | the `computer-use` worker at `AIO_COMPUTER_USE_URL` | `/v2/computer` |

A missing dependency makes only its own routes answer `503`; nothing else changes, and the daemon still binds.

`GET /v1/capabilities` reports the current capability state. The result is cached for 5 s and refreshed in the background; `?refresh=true` forces a probe. `aiod doctor --json` runs the same probes from the command line. The response shape is in [Sandbox Info & Capabilities](/daemon/basic/sandbox).

## State lives in memory

Command sessions, PTY sessions, code sessions, retained output, file watchers, and editor undo history live in process memory. Nothing is written to disk.

A restart or upgrade drops all of this state, so clients must start over. Files already on disk are untouched.

## Permission model

Two identities take part, and neither is a sandbox:

| Identity | What it decides |
| --- | --- |
| The daemon account (`AIO_DEFAULT_USER` on Linux) | The privileges of every file and command call |
| The request `user`, on commands, terminals, and code | The account the process runs as |
| The request `user`, on files | Who owns what the call creates |



A call can reach anything on the host that the daemon account can reach. aiod provides no per-request jail, chroot, or path allowlist; confining a deployment to a directory or tenant is the sandbox's job.

On Windows `user` is not implemented, and an explicit value answers `400`.

Access to the API is one gate: `AIO_API_KEY`, checked on every non-public route (see [Authentication](/daemon/basic/authentication)).

## Running the daemon

Add the binary to an image by copying one file:

```dockerfile
FROM your/base-image
COPY aiod /usr/local/bin/aiod
CMD ["aiod", "start"]
```

`aiod start` takes no required flags. It binds `0.0.0.0:18091`, uses the daemon account's home directory as its working directory, and resolves a runtime directory on its own.

Run it as the container's command or under an existing supervisor such as systemd, s6, or a custom init.

A fuller start line, for an image with an unprivileged account and an API key:

```bash
# Every flag has an environment variable of the same meaning:
# AIO_HOST, AIO_PORT, AIO_API_KEY, AIO_DEFAULT_USER, AIO_API_SURFACE, AIO_RUNTIME_DIR.
aiod start \
  --host 0.0.0.0 \
  --port 18091 \
  --api-key "$API_KEY" \
  --default-user gem \
  --api-surface full \
  --runtime-dir /run/aiod
```

`--default-user` sets the default account for requests, unless a request names another. `--api-surface v2` serves only `/v2/*` and `/mcp`.

`aiod -h` lists the subcommands: `start`, `doctor`, `version`, and `print-openapi`. `aiod start --help` lists every flag, its variable, and its default.

`aiod doctor` probes the host without starting the daemon: `bash`, `rg`, `tmux` on `PATH`, a browser process, and its CDP port. It prints one line per probe.

Two checks matter for orchestration:

```bash
curl "$BASE_URL/health"          # liveness: the process is up (no key needed)
curl "$BASE_URL/v1/capabilities" # readiness per capability: browser, code, desktop right now
```

Gate restarts on `/health`. Gate browser, code, and desktop routing on the matching section of `/v1/capabilities`.

On Kubernetes, one container usually runs aiod, with computer-use added where a desktop exists. A pod that also runs Chromium must allow the seccomp profile Chromium requires (`unconfined` if nothing stricter is available) and provide a sufficiently large `/dev/shm`; 4 GiB is a safe default. This is a Chromium requirement, not an extra requirement from aiod.

`aiod version` prints `aio-daemon <version>+<commit>`. `aiod print-openapi` writes the full spec to stdout.

The daemon serves `/openapi.json`, `/v1/openapi.json`, and `/v2/openapi.json`, without a documentation UI. The v2 reference is the [API Reference](/daemon/api).

## Platforms

aiod ships as a static binary for Linux (x86_64, arm64, riscv64) and Windows (x86_64). It needs no shared libraries and no installed runtime.

---

### En Examples Agent (`website/docs/en/examples/agent.md`)

# Agent Integration

This guide shows how to integrate AI agents with AIO Sandbox, leveraging the Model Context Protocol (MCP) and REST APIs for powerful agent workflows.

## Quick Start

### Basic Agent Setup

The simplest way to connect an agent to AIO Sandbox is through the MCP interface:

```
/* Detailed source-code truncated for AI context efficiency. */
```

### MCP Integration

AIO Sandbox provides built-in MCP servers for seamless agent integration:

```
/* Detailed source-code truncated for AI context efficiency. */
```

## Advanced Workflows

### Multi-Tool Agent Workflow

Here's an example of a complex agent that combines browser automation, file operations, and code execution:

```
/* Detailed source-code truncated for AI context efficiency. */
```

### Session Management

For long-running agent workflows, manage shell sessions effectively:

```
/* Detailed source-code truncated for AI context efficiency. */
```

## Integration Patterns

### LangChain Integration

Integrate AIO Sandbox with LangChain for advanced agent workflows:

```
/* Detailed source-code truncated for AI context efficiency. */
```

### OpenAI Assistant Integration

Create an OpenAI Assistant with sandbox capabilities:

```
/* Detailed source-code truncated for AI context efficiency. */
```

## Error Handling and Best Practices

### Robust Error Handling

```python
class RobustSandboxAgent(AIOSandboxAgent):
    async def safe_execute(self, command: str, max_retries: int = 3):
        """Execute command with retries and error handling"""
        for attempt in range(max_retries):
            try:
                result = await self.execute_shell(command)
                if result.get('success'):
                    return result
                else:
                    print(f"Attempt {attempt + 1} failed: {result.get('message')}")
            except Exception as e:
                print(f"Exception on attempt {attempt + 1}: {str(e)}")

            if attempt < max_retries - 1:
                await asyncio.sleep(2 ** attempt)  # Exponential backoff

        raise Exception(f"Command failed after {max_retries} attempts: {command}")

    async def validate_environment(self):
        """Validate sandbox environment before operations"""
        checks = [
            ("python --version", "Python runtime"),
            ("node --version", "Node.js runtime"),
            ("ls /tmp", "Temporary directory access")
        ]

        results = {}
        for command, description in checks:
            try:
                result = await self.safe_execute(command)
                results[description] = result.get('success', False)
            except Exception as e:
                results[description] = False
                print(f"Validation failed for {description}: {e}")

        return results
```

### Performance Optimization

```python
class OptimizedSandboxAgent(AIOSandboxAgent):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.connection_pool = aiohttp.TCPConnector(limit=10, limit_per_host=5)
        self.timeout = aiohttp.ClientTimeout(total=30)

    async def __aenter__(self):
        self.session = aiohttp.ClientSession(
            connector=self.connection_pool,
            timeout=self.timeout
        )
        return self

    async def batch_execute(self, commands: List[str]):
        """Execute multiple commands concurrently"""
        tasks = [self.execute_shell(cmd) for cmd in commands]
        results = await asyncio.gather(*tasks, return_exceptions=True)

        return [
            result if not isinstance(result, Exception) else {"error": str(result)}
            for result in results
        ]
```

## Testing Strategies

### Unit Testing

```python
import unittest
from unittest.mock import AsyncMock, patch

class TestSandboxAgent(unittest.IsolatedAsyncioTestCase):
    async def asyncSetUp(self):
        self.agent = AIOSandboxAgent("http://test-sandbox:8080")
        await self.agent.__aenter__()

    async def asyncTearDown(self):
        await self.agent.__aexit__(None, None, None)

    @patch('aiohttp.ClientSession.post')
    async def test_execute_shell_success(self, mock_post):
        # Mock successful response
        mock_response = AsyncMock()
        mock_response.json.return_value = {
            "success": True,
            "data": {"output": "Hello World"}
        }
        mock_post.return_value.__aenter__.return_value = mock_response

        result = await self.agent.execute_shell("echo 'Hello World'")
        self.assertTrue(result["success"])
        self.assertEqual(result["data"]["output"], "Hello World")

    async def test_file_operations(self):
        # Test file write and read cycle
        test_content = "Test file content"
        test_path = "/tmp/test_file.txt"

        # Write file
        write_result = await self.agent.write_file(test_path, test_content)
        self.assertTrue(write_result.get("success"))

        # Read file
        read_result = await self.agent.read_file(test_path)
        self.assertTrue(read_result.get("success"))
        self.assertEqual(read_result["data"]["content"], test_content)

if __name__ == "__main__":
    unittest.main()
```

## Production Deployment

### Docker Compose for Agent + Sandbox

```yaml
version: '3.8'
services:
  aio-sandbox:
    image: ghcr.io/agent-infra/sandbox:latest
    ports:
      - "127.0.0.1:8080:8080"
    volumes:
      - sandbox_data:/workspace
    environment:
      - SANDBOX_MEMORY_LIMIT=2g
      - SANDBOX_CPU_LIMIT=1000m
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/v1/sandbox"]
      interval: 30s
      timeout: 10s
      retries: 3

  ai-agent:
    build: ./agent
    environment:
      - SANDBOX_URL=http://aio-sandbox:8080
      - OPENAI_API_KEY=${OPENAI_API_KEY}
    depends_on:
      - aio-sandbox
    restart: unless-stopped

volumes:
  sandbox_data:
```

### Kubernetes Deployment

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ai-agent-with-sandbox
spec:
  replicas: 2
  selector:
    matchLabels:
      app: ai-agent
  template:
    metadata:
      labels:
        app: ai-agent
    spec:
      containers:
      - name: aio-sandbox
        image: ghcr.io/agent-infra/sandbox:latest
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "1Gi"
            cpu: "500m"
          limits:
            memory: "2Gi"
            cpu: "1000m"
        livenessProbe:
          httpGet:
            path: /v1/sandbox
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 30

      - name: ai-agent
        image: your-registry/ai-agent:latest
        env:
        - name: SANDBOX_URL
          value: "http://localhost:8080"
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
```

## Next Steps

Ready to build your own AI agents? Here are some recommended paths:

1. **Start Simple**: Begin with the basic agent setup and gradually add complexity
2. **Choose Your Framework**: Pick LangChain, OpenAI Assistants, or build custom solutions
3. **Test Thoroughly**: Use the provided testing strategies to ensure reliability
4. **Monitor Performance**: Implement logging and metrics for production deployments
5. **Scale Appropriately**: Use Docker Compose for development, Kubernetes for production

For more examples and advanced patterns:
- Check the [Browser Automation examples](/examples/browser)
- Explore [Terminal Integration patterns](/examples/terminal)
- Review the [API documentation](/api/) for detailed specifications
- Visit the [GitHub repository](https://github.com/agent-infra/sandbox) for latest updates

Need help? Join our community or open an issue on GitHub!

---

### En Examples Browser (`website/docs/en/examples/browser.md`)

# Browser Automation Examples

This guide shows how to use AIO Sandbox for browser automation, web scraping, and UI testing.

## Overview

AIO Sandbox provides multiple ways to interact with browsers:

- **VNC Access**: Visual browser interaction through remote desktop
- **Chrome DevTools Protocol (CDP)**: Programmatic browser control
- **Browser MCP Server**: High-level browser automation tools

## VNC Browser Access

### Basic VNC Interaction

Access the browser visually through VNC:

```bash
# Open VNC interface
open http://localhost:8080/vnc/index.html?autoconnect=true
```

The VNC interface provides:
- Full desktop environment with browser
- Visual interaction capabilities
- Screenshot and screen recording
- Mouse and keyboard input

### VNC in Automation Scripts

Use VNC for scenarios requiring visual verification:

```python
import requests
import time

# Take screenshot via VNC API
response = requests.get("http://localhost:8080/vnc/screenshot")
with open("screenshot.png", "wb") as f:
    f.write(response.content)

# Send keyboard input
requests.post("http://localhost:8080/vnc/keyboard", 
              json={"keys": "Hello World"})
```

## Chrome DevTools Protocol (CDP)

### CDP Connection

Connect to the browser using CDP:

```javascript
const CDP = require('chrome-remote-interface');

async function example() {
    const client = await CDP();
    const {Network, Page, Runtime} = client;
    
    // Enable necessary domains
    await Network.enable();
    await Page.enable();
    
    // Navigate to a page
    await Page.navigate({url: 'https://example.com'});
    await Page.loadEventFired();
    
    // Execute JavaScript
    const result = await Runtime.evaluate({
        expression: 'document.title'
    });
    
    console.log('Page title:', result.result.value);
    
    await client.close();
}

example().catch(console.error);
```

### Python CDP Example

Using Python with pychrome:

```python
import pychrome
import time

# Connect to browser
browser = pychrome.Browser(url="http://localhost:8080")
tab = browser.new_tab()

# Enable page domain
tab.Page.enable()

# Navigate to page
tab.Page.navigate(url="https://httpbin.org/get")
tab.wait(1)

# Get page content
result = tab.Runtime.evaluate(expression="document.body.innerText")
print("Page content:", result['result']['value'])

# Clean up
browser.close_tab(tab)
```

## Browser MCP Server API Reference

The `@agent-infra/mcp-server-browser` package provides the following tools:

### Navigation & Basic Actions
- `browser_navigate` - Navigate to a URL
- `browser_go_back` - Go back to previous page  
- `browser_go_forward` - Go forward to next page
- `browser_close` - Close the browser

### Element Interaction
- `browser_get_clickable_elements` - Get clickable/hoverable/selectable elements
- `browser_click` - Click an element (use with element index)
- `browser_hover` - Hover over an element
- `browser_select` - Select an element
- `browser_form_input_fill` - Fill input fields

### Content Retrieval
- `browser_get_text` - Get page text content
- `browser_get_markdown` - Get page as markdown
- `browser_read_links` - Get all page links
- `browser_screenshot` - Take screenshots

### Advanced Features
- `browser_scroll` - Scroll the page
- `browser_evaluate` - Execute JavaScript
- `browser_new_tab` - Open new tab
- `browser_switch_tab` - Switch between tabs
- `browser_tab_list` - List all tabs
- `browser_get_download_list` - Get downloaded files

### Vision Mode (Optional)
- `browser_vision_screen_capture` - Screenshot for vision mode
- `browser_vision_screen_click` - Vision-based clicking

## Browser MCP Server Integration

### Python with MCP Client

Use the Browser MCP server for high-level automation:

```python
import asyncio
from mcp import Client
import httpx

async def browser_automation():
    async with httpx.AsyncClient() as http_client:
        # Connect to MCP server
        async with Client("http://localhost:8080/mcp") as client:
            
            # Navigate to page
            result = await client.call_tool("browser_navigate", {
                "url": "https://example.com"
            })
            
            # Take screenshot
            screenshot = await client.call_tool("browser_screenshot", {
                "path": "/tmp/screenshot.png"
            })
            
            # Get page text content
            content = await client.call_tool("browser_get_text")
            
            # Get clickable elements
            elements = await client.call_tool("browser_get_clickable_elements")
            
            print("Page content:", content.content[0].text)
            print("Clickable elements:", elements.content)

asyncio.run(browser_automation())
```

### JavaScript MCP Integration

```javascript
const { McpClient } = require('@modelcontextprotocol/sdk');

async function browserAutomation() {
    const client = new McpClient("http://localhost:8080/mcp");
    
    try {
        await client.connect();
        
        // Navigate to page
        await client.callTool("browser_navigate", {
            url: "https://news.ycombinator.com"
        });
        
        // Wait for page load
        await new Promise(resolve => setTimeout(resolve, 2000));
        
        // Get clickable elements (like article titles)
        const elements = await client.callTool("browser_get_clickable_elements");
        
        // Get page markdown content
        const markdown = await client.callTool("browser_get_markdown");
        
        console.log("Clickable elements:", elements.content);
        console.log("Page content:", markdown.content);
        
    } finally {
        await client.disconnect();
    }
}

browserAutomation().catch(console.error);
```

## Web Scraping Examples

### E-commerce Price Monitoring

```python
import asyncio
import json
from datetime import datetime

async def monitor_prices():
    # Product URLs to monitor
    products = [
        {"name": "Laptop", "url": "https://example-store.com/laptop"},
        {"name": "Phone", "url": "https://example-store.com/phone"}
    ]
    
    results = []
    
    for product in products:
        # Use browser to navigate and extract price
        navigation_result = await client.call_tool("browser_navigate", {
            "url": product["url"]
        })
        
        # Get clickable elements and extract price
        elements = await client.call_tool("browser_get_clickable_elements")
        price_text = await client.call_tool("browser_get_text")
        
        results.append({
            "product": product["name"],
            "price": price_text.content[0].text,
            "timestamp": datetime.now().isoformat(),
            "url": product["url"]
        })
    
    # Save results to file via File API
    await client.call_tool("file_write", {
        "path": "/tmp/price_data.json",
        "content": json.dumps(results, indent=2)
    })
    
    return results

# Run price monitoring
prices = asyncio.run(monitor_prices())
print("Price monitoring complete:", prices)
```

### Social Media Content Extraction

```python
async def extract_social_posts():
    # Navigate to social media page
    await client.call_tool("browser_navigate", {
        "url": "https://example-social.com/trending"
    })
    
    # Wait for dynamic content to load
    await asyncio.sleep(3)
    
    # Get page content and clickable elements
    content = await client.call_tool("browser_get_text")
    elements = await client.call_tool("browser_get_clickable_elements")
    
    # Process extracted data
    return {
        "page_content": content.content[0].text,
        "clickable_elements": elements.content
    }
```

## Browser Testing Examples

### Form Automation Testing

```python
async def test_contact_form():
    # Navigate to form page
    await client.call_tool("browser_navigate", {
        "url": "https://example.com/contact"
    })
    
    # Get form elements first
    elements = await client.call_tool("browser_get_clickable_elements")
    
    # Fill out form fields using form_input_fill
    await client.call_tool("browser_form_input_fill", {
        "selector": "input[name='name']",
        "value": "Test User"
    })
    
    await client.call_tool("browser_form_input_fill", {
        "selector": "input[name='email']",  
        "value": "test@example.com"
    })
    
    await client.call_tool("browser_form_input_fill", {
        "selector": "textarea[name='message']",
        "value": "This is a test message"
    })
    
    # Submit form by clicking submit button
    await client.call_tool("browser_click", {
        "index": 0  # Use index of submit button from elements
    })
    
    # Wait for response
    await asyncio.sleep(2)
    
    # Verify success message by getting page text
    page_text = await client.call_tool("browser_get_text")
    
    assert "Thank you" in page_text.content[0].text
    print("Form submission test passed!")
```

### Performance Testing

```python
async def measure_page_performance():
    start_time = time.time()
    
    # Navigate to page
    await client.call_tool("browser_navigate", {
        "url": "https://example-app.com"
    })
    
    # Wait for page to load (use sleep or evaluate JS)
    await asyncio.sleep(3)
    
    load_time = time.time() - start_time
    
    # Get performance metrics using JavaScript evaluation
    metrics = await client.call_tool("browser_evaluate", {
        "expression": "JSON.stringify({loadTime: performance.timing.loadEventEnd - performance.timing.navigationStart, domContentLoaded: performance.timing.domContentLoadedEventEnd - performance.timing.navigationStart})"
    })
    
    return {
        "total_load_time": load_time,
        "performance_metrics": metrics.result
    }
```

## Playwright Integration

For advanced browser automation, integrate Playwright:

```python
from playwright.async_api import async_playwright
import asyncio

async def playwright_example():
    async with async_playwright() as p:
        # Connect to existing browser in AIO Sandbox
        browser = await p.chromium.connect_over_cdp(
            "ws://localhost:8080/cdp"
        )
        
        page = await browser.new_page()
        
        # Navigate and interact
        await page.goto("https://example.com")
        await page.fill("input[name='search']", "test query")
        await page.click("button[type='submit']")
        
        # Wait for results
        await page.wait_for_selector(".search-results")
        
        # Extract data
        results = await page.query_selector_all(".result-item")
        for result in results:
            title = await result.inner_text()
            print(f"Result: {title}")
        
        await browser.close()

asyncio.run(playwright_example())
```

## Selenium Integration

Use Selenium WebDriver with AIO Sandbox:

```python
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options

def selenium_example():
    # Configure Chrome options for remote connection
    chrome_options = Options()
    chrome_options.add_experimental_option("debuggerAddress", "localhost:9222")
    
    # Connect to browser
    driver = webdriver.Chrome(options=chrome_options)
    
    try:
        # Navigate and interact
        driver.get("https://example.com")
        
        # Find and interact with elements
        search_box = driver.find_element(By.NAME, "search")
        search_box.send_keys("test query")
        
        submit_button = driver.find_element(By.CSS_SELECTOR, "button[type='submit']")
        submit_button.click()
        
        # Wait and extract results
        driver.implicitly_wait(10)
        results = driver.find_elements(By.CSS_SELECTOR, ".result-item")
        
        for result in results:
            print(f"Result: {result.text}")
            
    finally:
        driver.quit()

selenium_example()
```

## Best Practices

### Resource Management

```python
async def managed_browser_session():
    try:
        # Navigate to starting page
        await client.call_tool("browser_navigate", {
            "url": "https://example.com"
        })
        
        # Perform browser operations
        yield client
        
    finally:
        # Close browser when done
        await client.call_tool("browser_close")
```

### Error Handling

```python
async def robust_browser_automation():
    max_retries = 3
    retry_count = 0
    
    while retry_count < max_retries:
        try:
            # Attempt browser operation
            result = await client.call_tool("browser_navigate", {
                "url": "https://example.com"
            })
            
            if result.success:
                break
                
        except Exception as e:
            retry_count += 1
            if retry_count >= max_retries:
                raise Exception(f"Browser operation failed after {max_retries} retries: {e}")
            
            # Wait before retry
            await asyncio.sleep(2 ** retry_count)
```

### Performance Optimization

```python
async def optimized_scraping():
    # Use multiple tabs for concurrent scraping
    urls = ["url1", "url2", "url3"]
    results = []
    
    for i, url in enumerate(urls):
        if i > 0:
            # Open new tab for additional URLs
            await client.call_tool("browser_new_tab")
            await client.call_tool("browser_switch_tab", {"index": i})
        
        # Navigate to URL
        await client.call_tool("browser_navigate", {"url": url})
        
        # Extract content
        content = await client.call_tool("browser_get_text")
        results.append(content)
    
    return results
```

## Debugging and Monitoring

### Screenshot-based Debugging

```python
async def debug_with_screenshots():
    # Take screenshot before action
    await client.call_tool("browser_screenshot", {
        "path": "/tmp/before_action.png"
    })
    
    # Perform action
    await client.call_tool("browser_click", {
        "selector": ".button"
    })
    
    # Take screenshot after action
    await client.call_tool("browser_screenshot", {
        "path": "/tmp/after_action.png"
    })
    
    # Compare or analyze screenshots as needed
```

### Console Log Monitoring

```python
async def monitor_console_logs():
    # Navigate to page
    await client.call_tool("browser_navigate", {
        "url": "https://example.com"
    })
    
    # Use JavaScript evaluation to check for console errors
    console_check = await client.call_tool("browser_evaluate", {
        "expression": """
        (() => {
            const logs = [];
            const originalError = console.error;
            console.error = (...args) => {
                logs.push({level: 'error', message: args.join(' ')});
                originalError.apply(console, args);
            };
            return JSON.stringify(logs);
        })()
        """
    })
    
    print("Console monitoring result:", console_check.result)
```

## Integration with Other AIO Sandbox Components

### Browser + File Operations

```python
async def browser_to_file_workflow():
    # Scrape data with browser
    await client.call_tool("browser_navigate", {
        "url": "https://api-docs.example.com"
    })
    
    # Extract API documentation
    docs = await client.call_tool("browser_get_text")
    
    # Save to file
    await client.call_tool("file_write", {
        "path": "/tmp/api_docs.txt",
        "content": docs.content[0].text
    })
    
    # Process with shell command
    await client.call_tool("shell_exec", {
        "command": "grep -E 'POST|GET|PUT|DELETE' /tmp/api_docs.txt > /tmp/endpoints.txt"
    })
```

### Browser + Code Execution

```python
async def browser_driven_analysis():
    # Scrape data
    await client.call_tool("browser_navigate", {
        "url": "https://data-source.com"
    })
    
    # Extract JSON data using JavaScript evaluation
    data = await client.call_tool("browser_evaluate", {
        "expression": "document.querySelector('pre.json-data').textContent"
    })
    
    # Process with Python execution
    analysis_code = f"""
import json
import pandas as pd

# Parse the scraped data
data = json.loads('''{data.result}''')

# Perform analysis
df = pd.DataFrame(data)
summary = df.describe()

print("Data Analysis Summary:")
print(summary.to_string())
"""
    
    result = await client.call_tool("jupyter_execute", {
        "code": analysis_code
    })
    
    print("Analysis Result:", result.content)
```

This comprehensive guide covers the main approaches to browser automation with AIO Sandbox. Choose the method that best fits your use case:

- **VNC** for visual interaction and debugging
- **CDP** for low-level browser control
- **MCP Browser Server** for high-level automation
- **Playwright/Selenium** for familiar frameworks

For more advanced scenarios, combine browser automation with other AIO Sandbox components like file operations, shell commands, and code execution.

---

### En Examples Terminal (`website/docs/en/examples/terminal.md`)

# Terminal Integration Examples

This section provides comprehensive examples for integrating with AIO Sandbox's WebSocket terminal interface.

## Basic Terminal Client

### Simple Node.js Implementation

```
/* Detailed source-code truncated for AI context efficiency. */
```

### Python Asyncio Implementation

```
/* Detailed source-code truncated for AI context efficiency. */
```

## Advanced Features

### Session Management and Reconnection

```
/* Detailed source-code truncated for AI context efficiency. */
```

### Multi-Session Management

```
/* Detailed source-code truncated for AI context efficiency. */
```

## Integration with Popular Libraries

### xterm.js Frontend Integration

```
/* Detailed source-code truncated for AI context efficiency. */
```

### React Component

```
/* Detailed source-code truncated for AI context efficiency. */
```

## Next Steps

- **[Browser Examples](/examples/browser)** - Learn browser automation
- **[Agent Integration](/examples/agent)** - Build AI workflows  
- **[API Reference](/api/)** - Detailed WebSocket API docs

---

### En Guide  Meta.Json (`website/docs/en/guide/_meta.json`)

[
  {
    "type": "dir",
    "label": "Getting Started",
    "name": "start"
  },
  {
    "type": "dir",
    "label": "Features",
    "name": "basic"
  },
  {
    "type": "dir",
    "label": "Advanced",
    "name": "advanced"
  }
]

---

### Public V1 Openapi.Json (`website/docs/public/v1/openapi.json`)

{
  "openapi": "3.1.0",
  "info": {
    "title": "FastAPI",
    "description": "\n- Browser\n    - CDP: [/cdp/json/version](/cdp/json/version)\n- Jupyter\n    - Notebook: [/jupyter](/jupyter)\n- MCP\n    - Streamable HTTP: [/mcp](/mcp) or [/v1/mcp](/v1/mcp)\n",
    "version": "1.9.4"
  },
  "paths": {
    "/v1/sandbox": {
      "get": {
        "tags": ["sandbox"],
        "summary": "Get Sandbox Context",
        "description": "Get sandbox environment information",
        "operationId": "get_sandbox_context_v1_sandbox_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/SandboxResponse"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "sandbox",
        "x-fern-sdk-method-name": "get_context"
      }
    },
    "/v1/sandbox/packages/python": {
      "get": {
        "tags": ["sandbox"],
        "summary": "Python Packages",
        "description": "Get installed Python packages",
        "operationId": "python_packages_v1_sandbox_packages_python_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "sandbox",
        "x-fern-sdk-method-name": "get_python_packages"
      }
    },
    "/v1/sandbox/packages/nodejs": {
      "get": {
        "tags": ["sandbox"],
        "summary": "Nodejs Packages",
        "description": "Get installed Node.js packages",
        "operationId": "nodejs_packages_v1_sandbox_packages_nodejs_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "sandbox",
        "x-fern-sdk-method-name": "get_nodejs_packages"
      }
    },
    "/v1/sandbox/hooks": {
      "post": {
        "tags": ["sandbox"],
        "summary": "Register Hook",
        "description": "Register a lifecycle hook. Currently supported events: shutdown.",
        "operationId": "register_hook_v1_sandbox_hooks_post",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/RegisterHookRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_SandboxHook_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "sandbox",
        "x-fern-sdk-method-name": "register_hook"
      },
      "get": {
        "tags": ["sandbox"],
        "summary": "List Hooks",
        "description": "List registered lifecycle hooks, optionally filtered by event.",
        "operationId": "list_hooks_v1_sandbox_hooks_get",
        "parameters": [
          {
            "name": "event",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "default": "shutdown",
              "title": "Event"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_list_SandboxHook__"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "sandbox",
        "x-fern-sdk-method-name": "list_hooks"
      }
    },
    "/v1/sandbox/hooks/{name}": {
      "delete": {
        "tags": ["sandbox"],
        "summary": "Remove Hook",
        "description": "Remove a hook by name. ENV hooks cannot be removed.",
        "operationId": "remove_hook_v1_sandbox_hooks__name__delete",
        "parameters": [
          {
            "name": "name",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Name"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "sandbox",
        "x-fern-sdk-method-name": "remove_hook"
      }
    },
    "/v1/sandbox/observe/status": {
      "get": {
        "tags": ["sandbox"],
        "summary": "Observe Status",
        "operationId": "observe_status_v1_sandbox_observe_status_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ObservationStatus_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "sandbox",
        "x-fern-sdk-method-name": "observe_status"
      }
    },
    "/v1/sandbox/observe/live": {
      "get": {
        "tags": ["sandbox"],
        "summary": "Observe Live",
        "operationId": "observe_live_v1_sandbox_observe_live_get",
        "parameters": [
          {
            "name": "top_rows",
            "in": "query",
            "required": false,
            "schema": {
              "type": "integer",
              "default": 10,
              "title": "Top Rows"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ObservationLiveSnapshot_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "sandbox",
        "x-fern-sdk-method-name": "observe_live"
      }
    },
    "/v1/sandbox/observe/start": {
      "post": {
        "tags": ["sandbox"],
        "summary": "Observe Start",
        "operationId": "observe_start_v1_sandbox_observe_start_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ObserveStartRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ObservationStartResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "sandbox",
        "x-fern-sdk-method-name": "observe_start"
      }
    },
    "/v1/sandbox/observe/stop": {
      "post": {
        "tags": ["sandbox"],
        "summary": "Observe Stop",
        "operationId": "observe_stop_v1_sandbox_observe_stop_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ObserveStopRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ObservationStopResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "sandbox",
        "x-fern-sdk-method-name": "observe_stop"
      }
    },
    "/v1/sandbox/observe/export": {
      "post": {
        "tags": ["sandbox"],
        "summary": "Observe Export",
        "operationId": "observe_export_v1_sandbox_observe_export_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ObserveExportRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ObservationExportResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "sandbox",
        "x-fern-sdk-method-name": "observe_export"
      }
    },
    "/v1/sandbox/observe/reports": {
      "get": {
        "tags": ["sandbox"],
        "summary": "Observe Reports",
        "operationId": "observe_reports_v1_sandbox_observe_reports_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_list_ObservationReportInfo__"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "sandbox",
        "x-fern-sdk-method-name": "observe_reports"
      }
    },
    "/v1/sandbox/observe/reports/{report_id}": {
      "get": {
        "tags": ["sandbox"],
        "summary": "Observe Report Download",
        "operationId": "observe_report_download_v1_sandbox_observe_reports__report_id__get",
        "parameters": [
          {
            "name": "report_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Report Id"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/gzip": {
                "schema": {
                  "type": "string",
                  "format": "binary"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "sandbox",
        "x-fern-sdk-method-name": "observe_report_download"
      },
      "delete": {
        "tags": ["sandbox"],
        "summary": "Observe Report Delete",
        "operationId": "observe_report_delete_v1_sandbox_observe_reports__report_id__delete",
        "parameters": [
          {
            "name": "report_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Report Id"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ObservationReportInfo_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "sandbox",
        "x-fern-sdk-method-name": "observe_report_delete"
      }
    },
    "/v1/shell/exec": {
      "post": {
        "tags": ["shell"],
        "summary": "Exec Command",
        "description": "Execute command in the specified shell session\nSupports SSE streaming if Accept header contains 'text/event-stream'",
        "operationId": "exec_command_v1_shell_exec_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ShellExecRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ShellCommandResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "shell",
        "x-fern-sdk-method-name": "exec_command"
      }
    },
    "/v1/shell/view": {
      "post": {
        "tags": ["shell"],
        "summary": "View Shell",
        "description": "View output of the specified shell session\nSupports SSE streaming if Accept header contains 'text/event-stream'",
        "operationId": "view_shell_v1_shell_view_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ShellViewRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ShellViewResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "shell",
        "x-fern-sdk-method-name": "view"
      }
    },
    "/v1/shell/wait": {
      "post": {
        "tags": ["shell"],
        "summary": "Wait For Process",
        "description": "Wait for the process in the specified shell session to return",
        "operationId": "wait_for_process",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ShellWaitRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ShellWaitResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "shell",
        "x-fern-sdk-method-name": "wait_for_process"
      }
    },
    "/v1/shell/write": {
      "post": {
        "tags": ["shell"],
        "summary": "Write To Process",
        "description": "Write input to the process in the specified shell session",
        "operationId": "write_to_process",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ShellWriteToProcessRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ShellWriteResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "shell",
        "x-fern-sdk-method-name": "write_to_process"
      }
    },
    "/v1/shell/kill": {
      "post": {
        "tags": ["shell"],
        "summary": "Kill Process",
        "description": "Terminate the process in the specified shell session",
        "operationId": "kill_shell_process",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ShellKillProcessRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ShellKillResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "shell",
        "x-fern-sdk-method-name": "kill_process"
      }
    },
    "/v1/shell/sessions/create": {
      "post": {
        "tags": ["shell"],
        "summary": "Create Session",
        "description": "Create a new shell session and return its ID\nIf id already exists, return the existing session",
        "operationId": "create_shell_session",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ShellCreateSessionRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ShellCreateSessionResponse_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "shell",
        "x-fern-sdk-method-name": "create_session"
      }
    },
    "/v1/shell/sessions/update": {
      "post": {
        "tags": ["shell"],
        "summary": "Update Session",
        "description": "Update shell session configuration (e.g., no_change_timeout)",
        "operationId": "update_shell_session",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ShellUpdateSessionRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "shell",
        "x-fern-sdk-method-name": "update_session"
      }
    },
    "/v1/shell/terminal-url": {
      "get": {
        "tags": ["shell"],
        "summary": "Get Terminal Url",
        "description": "Create a new shell session and return the terminal URL",
        "operationId": "get_terminal_url",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_str_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "shell",
        "x-fern-sdk-method-name": "get_terminal_url"
      }
    },
    "/v1/shell/sessions/stats": {
      "get": {
        "tags": ["shell"],
        "summary": "Get Session Stats",
        "description": "Return aggregate statistics for shell sessions.",
        "operationId": "get_shell_session_stats",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ShellSessionStats_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "shell",
        "x-fern-sdk-method-name": "get_session_stats"
      }
    },
    "/v1/shell/sessions": {
      "get": {
        "tags": ["shell"],
        "summary": "List Sessions",
        "description": "List all active shell sessions",
        "operationId": "list_shell_sessions",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ActiveShellSessionsResult_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "shell",
        "x-fern-sdk-method-name": "list_sessions"
      },
      "delete": {
        "tags": ["shell"],
        "summary": "Cleanup All Sessions",
        "description": "Cleanup all active shell sessions",
        "operationId": "cleanup_all_sessions",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "shell",
        "x-fern-sdk-method-name": "cleanup_all_sessions"
      }
    },
    "/v1/shell/sessions/{session_id}": {
      "delete": {
        "tags": ["shell"],
        "summary": "Cleanup Session",
        "description": "Manually cleanup a specific shell session",
        "operationId": "cleanup_shell_session",
        "parameters": [
          {
            "name": "session_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Session Id"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "shell",
        "x-fern-sdk-method-name": "cleanup_session"
      }
    },
    "/v1/bash/exec": {
      "post": {
        "tags": ["bash"],
        "summary": "Exec",
        "description": "Execute a bash command.\n\nStatus values in `data.status`:\n- `running`: the process is still executing. Returned immediately for\n  `async_mode=true`, or when sync mode hits `timeout` before completion.\n- `completed`: the process exited and `exit_code` is available. This does\n  not imply success; non-zero shell exit codes still use `completed`.\n- `timed_out`: the process exceeded `hard_timeout` and was force-killed.\n- `killed`: the process was terminated by `/v1/bash/kill`, session cleanup,\n  or an internal execution failure before normal completion.\n\nHow to consume the result:\n- Treat `status` as lifecycle state, not success/failure.\n- If `status=running`, keep polling `/v1/bash/output` with the returned\n  `session_id`, `command_id`, `offset`, and `stderr_offset`.\n- If `status=completed`, check `exit_code`: `0` means success, non-zero\n  means the command finished but failed.\n- If `status=timed_out` or `status=killed`, show the current output as a\n  partial result and surface the command as interrupted.\n- Empty `stdout` or `stderr` does not mean the command did not run.\n\n- async_mode=true: returns immediately with RUNNING status\n- async_mode=false + timeout: waits up to timeout, then returns RUNNING if not done\n- async_mode=false + no timeout: waits until command completes\n- hard_timeout: kills the process after this many seconds\n- env: extra environment variables for this command only",
        "operationId": "exec",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/BashExecRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_BashExecResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "bash",
        "x-fern-sdk-method-name": "exec"
      }
    },
    "/v1/bash/output": {
      "post": {
        "tags": ["bash"],
        "summary": "Output",
        "description": "Read output from a bash session using offset-based streaming.\n\n`data.command.status` uses the same command-status values as `/v1/bash/exec`:\n`running`, `completed`, `timed_out`, or `killed`.\n\nRecommended consumption pattern:\n- Start with `/v1/bash/exec`.\n- If the command is still `running`, call `/v1/bash/output` repeatedly.\n- Reuse the returned `offset` and `stderr_offset` to fetch only new data.\n- Stop polling when `data.command.status` is no longer `running`.\n- Use the final `exit_code` to decide whether the command succeeded.\n\n- offset/stderr_offset: byte offsets to read from (use values from previous response)\n- wait=true: long-poll until new output arrives or wait_timeout",
        "operationId": "output",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/BashOutputRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_BashOutputResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "bash",
        "x-fern-sdk-method-name": "output"
      }
    },
    "/v1/bash/write": {
      "post": {
        "tags": ["bash"],
        "summary": "Write",
        "description": "Write input to a bash session's stdin.",
        "operationId": "write",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/BashWriteRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "bash",
        "x-fern-sdk-method-name": "write"
      }
    },
    "/v1/bash/kill": {
      "post": {
        "tags": ["bash"],
        "summary": "Kill",
        "description": "Send a signal to a bash session's process.",
        "operationId": "kill",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/BashKillRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "bash",
        "x-fern-sdk-method-name": "kill"
      }
    },
    "/v1/bash/sessions": {
      "get": {
        "tags": ["bash"],
        "summary": "Sessions",
        "description": "List all active bash sessions.\n\nSession status values:\n- `ready`: session exists and can accept commands\n- `closed`: session has been closed and cannot be reused",
        "operationId": "sessions",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_list_BashSessionInfo__"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "bash",
        "x-fern-sdk-method-name": "sessions"
      }
    },
    "/v1/bash/sessions/create": {
      "post": {
        "tags": ["bash"],
        "summary": "Create Session",
        "description": "Create a new bash session.",
        "operationId": "create_session",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/BashSessionCreateRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_BashSessionInfo_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "bash",
        "x-fern-sdk-method-name": "create_session"
      }
    },
    "/v1/bash/sessions/{session_id}/close": {
      "post": {
        "tags": ["bash"],
        "summary": "Close Session",
        "description": "Close a bash session.",
        "operationId": "close_session",
        "parameters": [
          {
            "name": "session_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Session Id"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "bash",
        "x-fern-sdk-method-name": "close_session"
      }
    },
    "/v1/file/read": {
      "post": {
        "tags": ["file"],
        "summary": "Read File",
        "description": "Read file content",
        "operationId": "read_file",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FileReadRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_Union_FileReadResult__FileOperationError__"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "read_file"
      }
    },
    "/v1/file/write": {
      "post": {
        "tags": ["file"],
        "summary": "Write File",
        "description": "Write file content (supports both text and binary files)\n\nFor binary files, set encoding to 'base64' and provide base64-encoded content.\nFor text files, use default 'utf-8' encoding.",
        "operationId": "write_file",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FileWriteRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_Union_FileWriteResult__FileOperationError__"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "write_file"
      }
    },
    "/v1/file/replace": {
      "post": {
        "tags": ["file"],
        "summary": "Replace In File",
        "description": "Replace string in file",
        "operationId": "replace_in_file",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FileReplaceRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_Union_FileReplaceResult__FileOperationError__"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "replace_in_file"
      }
    },
    "/v1/file/search": {
      "post": {
        "tags": ["file"],
        "summary": "Search In File",
        "description": "Search in file content",
        "operationId": "search_in_file",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FileSearchRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_Union_FileSearchResult__FileOperationError__"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "search_in_file"
      }
    },
    "/v1/file/find": {
      "post": {
        "tags": ["file"],
        "summary": "Find Files",
        "description": "Find files by name pattern",
        "operationId": "find_files_v1_file_find_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FileFindRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_Union_FileFindResult__FileOperationError__"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "find_files"
      }
    },
    "/v1/file/grep": {
      "post": {
        "tags": ["file"],
        "summary": "Grep Files",
        "description": "Multi-file content search (grep) with regex or fixed string support",
        "operationId": "grep_files",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FileGrepRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_Union_FileGrepResult__FileOperationError__"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "grep_files"
      }
    },
    "/v1/file/glob": {
      "post": {
        "tags": ["file"],
        "summary": "Glob Files",
        "description": "Enhanced file glob matching with optional metadata",
        "operationId": "glob_files",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FileGlobRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_Union_FileGlobResult__FileOperationError__"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "glob_files"
      }
    },
    "/v1/file/upload": {
      "post": {
        "tags": ["file"],
        "summary": "Upload File",
        "description": "Upload file using streaming",
        "operationId": "upload_file",
        "requestBody": {
          "content": {
            "multipart/form-data": {
              "schema": {
                "$ref": "#/components/schemas/Body_upload_file"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_Union_FileUploadResult__FileOperationError__"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "upload_file"
      }
    },
    "/v1/file/download": {
      "get": {
        "tags": ["file"],
        "summary": "Download File",
        "description": "Download a file.\n\nWhen ``change_policy=abort``, the server aborts the download if the source\nfile changes before streaming starts or while bytes are being sent.",
        "operationId": "download_file",
        "parameters": [
          {
            "name": "path",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Path"
            }
          },
          {
            "name": "change_policy",
            "in": "query",
            "required": false,
            "schema": {
              "$ref": "#/components/schemas/FileDownloadChangePolicy",
              "default": "ignore"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/octet-stream": {
                "schema": {
                  "type": "string",
                  "format": "binary"
                }
              }
            }
          },
          "409": {
            "description": "File changed before or during download when change_policy=abort"
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "download_file"
      }
    },
    "/v1/file/list": {
      "post": {
        "tags": ["file"],
        "summary": "List Path",
        "description": "List path contents with flexible options",
        "operationId": "list_path_v1_file_list_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FileListRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_Union_FileListResult__FileOperationError__"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "list_path"
      }
    },
    "/v1/file/str_replace_editor": {
      "post": {
        "tags": ["file"],
        "summary": "Str Replace Editor",
        "description": "An filesystem editor tool that allows the agent to\n- view\n- create\n- navigate\n- edit files\nThe tool parameters are defined by Anthropic and are not editable.",
        "operationId": "str_replace_editor_v1_file_str_replace_editor_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/StrReplaceEditorRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_Union_StrReplaceEditorResult__FileOperationError__"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "str_replace_editor"
      }
    },
    "/v1/jupyter/execute": {
      "post": {
        "tags": ["jupyter"],
        "summary": "Execute Jupyter Code",
        "description": "Execute Python code using Jupyter kernel with session persistence\n\nThis endpoint allows you to execute Python code and get results back.\nYou can optionally specify a kernel_name.\nIf omitted, the runtime default resolved from `PYTHON_VERSION` is used.\nUse session_id to maintain variable state across multiple requests.\nSessions automatically expire after 30 minutes of inactivity.",
        "operationId": "jupyter_execute_code",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/JupyterExecuteRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_JupyterExecuteResponse_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-method-name": "execute_code",
        "x-fern-sdk-group-name": "jupyter"
      }
    },
    "/v1/jupyter/info": {
      "get": {
        "tags": ["jupyter"],
        "summary": "Jupyter Info",
        "description": "Get information about available Jupyter kernels",
        "operationId": "get_jupyter_info",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_JupyterInfoResponse_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "jupyter",
        "x-fern-sdk-method-name": "get_info"
      }
    },
    "/v1/jupyter/sessions": {
      "get": {
        "tags": ["jupyter"],
        "summary": "List Sessions",
        "description": "List all active Jupyter sessions",
        "operationId": "list_jupyter_sessions",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ActiveSessionsResult_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "jupyter",
        "x-fern-sdk-method-name": "list_sessions"
      },
      "delete": {
        "tags": ["jupyter"],
        "summary": "Cleanup All Sessions",
        "description": "Cleanup all active sessions",
        "operationId": "delete_jupyter_sessions",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "jupyter",
        "x-fern-sdk-method-name": "delete_sessions"
      }
    },
    "/v1/jupyter/sessions/{session_id}": {
      "delete": {
        "tags": ["jupyter"],
        "summary": "Cleanup Session",
        "description": "Manually cleanup a specific session",
        "operationId": "delete_jupyter_session",
        "parameters": [
          {
            "name": "session_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Session Id"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "jupyter",
        "x-fern-sdk-method-name": "delete_session"
      }
    },
    "/v1/jupyter/sessions/create": {
      "post": {
        "tags": ["jupyter"],
        "summary": "Create Jupyter Session",
        "description": "Create a new Jupyter session",
        "operationId": "create_jupyter_session",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/JupyterCreateSessionRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_JupyterCreateSessionResponse_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "jupyter",
        "x-fern-sdk-method-name": "create_session"
      }
    },
    "/v1/nodejs/execute": {
      "post": {
        "tags": ["nodejs"],
        "summary": "Execute Nodejs Code",
        "description": "Execute JavaScript code using Node.js\n\nThis endpoint allows you to execute JavaScript code and get results back.\n\nFor stateless execution (default):\n- Each request creates a fresh execution environment\n- Environment is cleaned up automatically after execution\n\nFor stateful execution (stateful=True):\n- Uses persistent REPL session that maintains state between requests\n- Variables, functions, and imports persist across calls\n- Returns session_id to continue the session in subsequent requests\n- Supports async/await at top level",
        "operationId": "execute_nodejs_code",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/NodeJSExecuteRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_NodeJSExecuteResponse_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "nodejs",
        "x-fern-sdk-method-name": "execute_code"
      }
    },
    "/v1/nodejs/info": {
      "get": {
        "tags": ["nodejs"],
        "summary": "Nodejs Info",
        "description": "Get information about Node.js REPL runtime, including installed packages\n\nReturns Node.js version, npm version, and lists of installed packages\nfrom both the runtime directory and global npm directory.",
        "operationId": "get_nodejs_info",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_NodeJSRuntimeInfo_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "nodejs",
        "x-fern-sdk-method-name": "get_info"
      }
    },
    "/v1/nodejs/sessions": {
      "post": {
        "tags": ["nodejs"],
        "summary": "Create Nodejs Session",
        "description": "Create a new Node.js REPL session\n\nCreates a new persistent REPL session with configurable working directory\nand idle timeout. Use the returned session_id in subsequent execute requests.",
        "operationId": "create_nodejs_session",
        "parameters": [
          {
            "name": "version",
            "in": "query",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "description": "Node.js version to target: \"node20\", \"node22\", \"node24\", or aliases \"20\", \"22\", \"24\"",
              "title": "Version"
            },
            "description": "Node.js version to target: \"node20\", \"node22\", \"node24\", or aliases \"20\", \"22\", \"24\""
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/NodeJSCreateSessionRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_NodeJSCreateSessionResponse_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "nodejs",
        "x-fern-sdk-method-name": "create_session"
      },
      "get": {
        "tags": ["nodejs"],
        "summary": "List Nodejs Sessions",
        "description": "List all active Node.js REPL sessions\n\nReturns information about all active sessions including their state,\nworking directory, and idle time.",
        "operationId": "list_nodejs_sessions",
        "parameters": [
          {
            "name": "version",
            "in": "query",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "description": "Node.js version to target: \"node20\", \"node22\", \"node24\", or aliases \"20\", \"22\", \"24\"",
              "title": "Version"
            },
            "description": "Node.js version to target: \"node20\", \"node22\", \"node24\", or aliases \"20\", \"22\", \"24\""
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_NodeJSSessionListResponse_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "nodejs",
        "x-fern-sdk-method-name": "list_sessions"
      }
    },
    "/v1/nodejs/sessions/{session_id}": {
      "get": {
        "tags": ["nodejs"],
        "summary": "Get Nodejs Session",
        "description": "Get information about a specific Node.js REPL session\n\nReturns detailed information about a session including its state,\nworking directory, creation time, and idle time.",
        "operationId": "get_nodejs_session",
        "parameters": [
          {
            "name": "session_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Session Id"
            }
          },
          {
            "name": "version",
            "in": "query",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "description": "Node.js version to target: \"node20\", \"node22\", \"node24\", or aliases \"20\", \"22\", \"24\"",
              "title": "Version"
            },
            "description": "Node.js version to target: \"node20\", \"node22\", \"node24\", or aliases \"20\", \"22\", \"24\""
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_NodeJSSessionResponse_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "nodejs",
        "x-fern-sdk-method-name": "get_session"
      },
      "patch": {
        "tags": ["nodejs"],
        "summary": "Update Nodejs Session",
        "description": "Update a Node.js REPL session configuration\n\nUpdates session properties like maximum idle time or working directory.",
        "operationId": "update_nodejs_session",
        "parameters": [
          {
            "name": "session_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Session Id"
            }
          },
          {
            "name": "version",
            "in": "query",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "description": "Node.js version to target: \"node20\", \"node22\", \"node24\", or aliases \"20\", \"22\", \"24\"",
              "title": "Version"
            },
            "description": "Node.js version to target: \"node20\", \"node22\", \"node24\", or aliases \"20\", \"22\", \"24\""
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/NodeJSUpdateSessionRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_NodeJSUpdateSessionResponse_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "nodejs",
        "x-fern-sdk-method-name": "update_session"
      },
      "delete": {
        "tags": ["nodejs"],
        "summary": "Delete Nodejs Session",
        "description": "Delete a Node.js REPL session\n\nTerminates the session and releases all associated resources.",
        "operationId": "delete_nodejs_session",
        "parameters": [
          {
            "name": "session_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Session Id"
            }
          },
          {
            "name": "version",
            "in": "query",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "description": "Node.js version to target: \"node20\", \"node22\", \"node24\", or aliases \"20\", \"22\", \"24\"",
              "title": "Version"
            },
            "description": "Node.js version to target: \"node20\", \"node22\", \"node24\", or aliases \"20\", \"22\", \"24\""
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_NodeJSDeleteSessionResponse_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "nodejs",
        "x-fern-sdk-method-name": "delete_session"
      }
    },
    "/v1/mcp/{server_name}/tools": {
      "get": {
        "tags": ["mcp"],
        "summary": "List Mcp Tools",
        "description": "List all available tools from the specified MCP server\n\nArgs:\n    server_name: The name of the MCP server as defined in mcp-servers.json\n\nReturns:\n    Response containing the list of available tools with their descriptions and parameters",
        "operationId": "list_mcp_tools_v1_mcp__server_name__tools_get",
        "parameters": [
          {
            "name": "server_name",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "description": "Name of the MCP server",
              "title": "Server Name"
            },
            "description": "Name of the MCP server"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ListToolsResultModel_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/v1/mcp/{server_name}/tools/{tool_name}": {
      "post": {
        "tags": ["mcp"],
        "summary": "Execute Mcp Tool",
        "description": "Execute a specific tool on the specified MCP server\n\nArgs:\n    server_name: The name of the MCP server as defined in mcp-servers.json\n    tool_name: The name of the tool to execute\n    arguments: Tool arguments dictionary\n\nReturns:\n    Response containing the tool execution results",
        "operationId": "execute_mcp_tool_v1_mcp__server_name__tools__tool_name__post",
        "parameters": [
          {
            "name": "server_name",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "description": "Name of the MCP server",
              "title": "Server Name"
            },
            "description": "Name of the MCP server"
          },
          {
            "name": "tool_name",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "description": "Name of the tool to execute",
              "title": "Tool Name"
            },
            "description": "Name of the tool to execute"
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "type": "object",
                "additionalProperties": true,
                "default": {},
                "title": "Arguments"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_CallToolResultModel_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/v1/mcp/servers": {
      "get": {
        "tags": ["mcp"],
        "summary": "List Mcp Servers",
        "description": "List all configured MCP servers\n\nReturns:\n    Response containing the list of configured and filtered MCP servers",
        "operationId": "list_mcp_servers_v1_mcp_servers_get",
        "parameters": [
          {
            "name": "include_hidden",
            "in": "query",
            "required": false,
            "schema": {
              "type": "boolean",
              "description": "Whether to include hidden MCP servers in the response",
              "default": false,
              "title": "Include Hidden"
            },
            "description": "Whether to include hidden MCP servers in the response"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_List_str__"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        }
      }
    },
    "/v1/browser/info": {
      "get": {
        "tags": ["browser"],
        "summary": "Get Browser Info",
        "description": "Get information about browser, like cdp url, viewport size, etc.",
        "operationId": "get_browser_info_v1_browser_info_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_BrowserInfoResult_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser",
        "x-fern-sdk-method-name": "get_info"
      }
    },
    "/v1/browser/screenshot": {
      "get": {
        "tags": ["browser"],
        "summary": "Take Screenshot",
        "description": "Take a screenshot of the current display.\n\nReturns:\n    StreamingResponse: PNG or JPEG image data with proper headers including display and screenshot dimensions",
        "operationId": "take_screenshot_v1_browser_screenshot_get",
        "parameters": [
          {
            "name": "format",
            "in": "query",
            "required": false,
            "schema": {
              "enum": ["png", "jpg", "jpeg"],
              "type": "string",
              "default": "png",
              "title": "Format"
            }
          },
          {
            "name": "quality",
            "in": "query",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "type": "integer",
                  "maximum": 100,
                  "minimum": 0
                },
                {
                  "type": "null"
                }
              ],
              "title": "Quality"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Screenshot image",
            "content": {
              "image/png": {},
              "image/jpeg": {}
            },
            "headers": {
              "x-screen-width": {
                "description": "Screen width",
                "schema": {
                  "type": "string"
                }
              },
              "x-screen-height": {
                "description": "Screen height",
                "schema": {
                  "type": "string"
                }
              },
              "x-image-width": {
                "description": "Image width",
                "schema": {
                  "type": "string"
                }
              },
              "x-image-height": {
                "description": "Image height",
                "schema": {
                  "type": "string"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser",
        "x-fern-sdk-method-name": "screenshot"
      }
    },
    "/v1/browser/actions": {
      "post": {
        "tags": ["browser"],
        "summary": "Execute Action",
        "description": "Execute a validated action on the current display.",
        "operationId": "execute_action_v1_browser_actions_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "oneOf": [
                  {
                    "$ref": "#/components/schemas/MoveToAction"
                  },
                  {
                    "$ref": "#/components/schemas/MoveRelAction"
                  },
                  {
                    "$ref": "#/components/schemas/ClickAction"
                  },
                  {
                    "$ref": "#/components/schemas/MouseDownAction"
                  },
                  {
                    "$ref": "#/components/schemas/MouseUpAction"
                  },
                  {
                    "$ref": "#/components/schemas/RightClickAction"
                  },
                  {
                    "$ref": "#/components/schemas/DoubleClickAction"
                  },
                  {
                    "$ref": "#/components/schemas/DragToAction"
                  },
                  {
                    "$ref": "#/components/schemas/DragRelAction"
                  },
                  {
                    "$ref": "#/components/schemas/ScrollAction"
                  },
                  {
                    "$ref": "#/components/schemas/TypingAction"
                  },
                  {
                    "$ref": "#/components/schemas/PressAction"
                  },
                  {
                    "$ref": "#/components/schemas/KeyDownAction"
                  },
                  {
                    "$ref": "#/components/schemas/KeyUpAction"
                  },
                  {
                    "$ref": "#/components/schemas/HotkeyAction"
                  },
                  {
                    "$ref": "#/components/schemas/WaitAction"
                  }
                ],
                "title": "Action",
                "discriminator": {
                  "propertyName": "action_type",
                  "mapping": {
                    "MOVE_TO": "#/components/schemas/MoveToAction",
                    "MOVE_REL": "#/components/schemas/MoveRelAction",
                    "CLICK": "#/components/schemas/ClickAction",
                    "MOUSE_DOWN": "#/components/schemas/MouseDownAction",
                    "MOUSE_UP": "#/components/schemas/MouseUpAction",
                    "RIGHT_CLICK": "#/components/schemas/RightClickAction",
                    "DOUBLE_CLICK": "#/components/schemas/DoubleClickAction",
                    "DRAG_TO": "#/components/schemas/DragToAction",
                    "DRAG_REL": "#/components/schemas/DragRelAction",
                    "SCROLL": "#/components/schemas/ScrollAction",
                    "TYPING": "#/components/schemas/TypingAction",
                    "PRESS": "#/components/schemas/PressAction",
                    "KEY_DOWN": "#/components/schemas/KeyDownAction",
                    "KEY_UP": "#/components/schemas/KeyUpAction",
                    "HOTKEY": "#/components/schemas/HotkeyAction",
                    "WAIT": "#/components/schemas/WaitAction"
                  }
                }
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ActionResponse"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser",
        "x-fern-sdk-method-name": "execute_action"
      }
    },
    "/v1/browser/config": {
      "post": {
        "tags": ["browser"],
        "summary": "Set Config",
        "description": "Execute a validated action on the current display.",
        "operationId": "set_config_v1_browser_config_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/BrowserConfigRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser",
        "x-fern-sdk-method-name": "set_config"
      }
    },
    "/v1/browser/page/navigate": {
      "post": {
        "tags": ["browser"],
        "summary": "Navigate",
        "description": "Navigate the current page to a URL.",
        "operationId": "navigate_v1_browser_page_navigate_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/NavigateRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_dict_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "navigate"
      }
    },
    "/v1/browser/page/back": {
      "post": {
        "tags": ["browser"],
        "summary": "Go Back",
        "description": "Go back in browser history.",
        "operationId": "go_back_v1_browser_page_back_post",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "back"
      }
    },
    "/v1/browser/page/forward": {
      "post": {
        "tags": ["browser"],
        "summary": "Go Forward",
        "description": "Go forward in browser history.",
        "operationId": "go_forward_v1_browser_page_forward_post",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "forward"
      }
    },
    "/v1/browser/page/reload": {
      "post": {
        "tags": ["browser"],
        "summary": "Reload",
        "description": "Reload the current page.",
        "operationId": "reload_v1_browser_page_reload_post",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "reload"
      }
    },
    "/v1/browser/page/click": {
      "post": {
        "tags": ["browser"],
        "summary": "Click",
        "description": "Click an element by selector, index, or coordinates.",
        "operationId": "click_v1_browser_page_click_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ClickRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "click"
      }
    },
    "/v1/browser/page/fill": {
      "post": {
        "tags": ["browser"],
        "summary": "Fill",
        "description": "Fill an input field.",
        "operationId": "fill_v1_browser_page_fill_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FillRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "fill"
      }
    },
    "/v1/browser/page/type": {
      "post": {
        "tags": ["browser"],
        "summary": "Type Text",
        "description": "Type text with optional delay between keystrokes.",
        "operationId": "type_text_v1_browser_page_type_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/TypeTextRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "type_text"
      }
    },
    "/v1/browser/page/press_key": {
      "post": {
        "tags": ["browser"],
        "summary": "Press Key",
        "description": "Press a single key.",
        "operationId": "press_key_v1_browser_page_press_key_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/KeyRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "press_key"
      }
    },
    "/v1/browser/page/hot_key": {
      "post": {
        "tags": ["browser"],
        "summary": "Hot Key",
        "description": "Press a key combination.",
        "operationId": "hot_key_v1_browser_page_hot_key_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/HotKeyRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "hot_key"
      }
    },
    "/v1/browser/page/hover": {
      "post": {
        "tags": ["browser"],
        "summary": "Hover",
        "description": "Hover over an element by selector or coordinates.",
        "operationId": "hover_v1_browser_page_hover_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/HoverRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "hover"
      }
    },
    "/v1/browser/page/select_option": {
      "post": {
        "tags": ["browser"],
        "summary": "Select Option",
        "description": "Select an option in a dropdown.",
        "operationId": "select_option_v1_browser_page_select_option_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/SelectOptionRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "select_option"
      }
    },
    "/v1/browser/page/check": {
      "post": {
        "tags": ["browser"],
        "summary": "Check",
        "description": "Check a checkbox.",
        "operationId": "check_v1_browser_page_check_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CheckRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "check"
      }
    },
    "/v1/browser/page/uncheck": {
      "post": {
        "tags": ["browser"],
        "summary": "Uncheck",
        "description": "Uncheck a checkbox.",
        "operationId": "uncheck_v1_browser_page_uncheck_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CheckRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "uncheck"
      }
    },
    "/v1/browser/page/upload_file": {
      "post": {
        "tags": ["browser"],
        "summary": "Upload File",
        "description": "Upload files to a file input element.",
        "operationId": "upload_file_v1_browser_page_upload_file_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/UploadFileRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "upload_file"
      }
    },
    "/v1/browser/page/fill_form": {
      "post": {
        "tags": ["browser"],
        "summary": "Fill Form",
        "description": "Batch fill multiple form fields.",
        "operationId": "fill_form_v1_browser_page_fill_form_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FormFillRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "fill_form"
      }
    },
    "/v1/browser/page/scroll": {
      "post": {
        "tags": ["browser"],
        "summary": "Scroll",
        "description": "Scroll the page in a direction.",
        "operationId": "scroll_v1_browser_page_scroll_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ScrollRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "scroll"
      }
    },
    "/v1/browser/page/scroll_to": {
      "post": {
        "tags": ["browser"],
        "summary": "Scroll To",
        "description": "Scroll to an absolute position.",
        "operationId": "scroll_to_v1_browser_page_scroll_to_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ScrollToRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "scroll_to"
      }
    },
    "/v1/browser/page/scroll_to_element": {
      "post": {
        "tags": ["browser"],
        "summary": "Scroll To Element",
        "description": "Scroll an element into view.",
        "operationId": "scroll_to_element_v1_browser_page_scroll_to_element_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ScrollToElementRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "scroll_to_element"
      }
    },
    "/v1/browser/page/screenshot": {
      "get": {
        "tags": ["browser"],
        "summary": "Page Screenshot",
        "description": "Capture a page screenshot.",
        "operationId": "page_screenshot_v1_browser_page_screenshot_get",
        "parameters": [
          {
            "name": "full_page",
            "in": "query",
            "required": false,
            "schema": {
              "type": "boolean",
              "default": false,
              "title": "Full Page"
            }
          },
          {
            "name": "format",
            "in": "query",
            "required": false,
            "schema": {
              "type": "string",
              "default": "png",
              "title": "Format"
            }
          },
          {
            "name": "quality",
            "in": "query",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "type": "integer"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Quality"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Page-level screenshot via Playwright",
            "content": {
              "image/png": {}
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "screenshot"
      }
    },
    "/v1/browser/page/record": {
      "post": {
        "tags": ["browser"],
        "summary": "Page Record",
        "description": "Record page screencast (once/start/pause/resume/stop/status).",
        "operationId": "page_record_v1_browser_page_record_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/RecordRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_dict_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "record"
      }
    },
    "/v1/browser/page/html": {
      "get": {
        "tags": ["browser"],
        "summary": "Get Html",
        "description": "Get the page HTML content.",
        "operationId": "get_html_v1_browser_page_html_get",
        "parameters": [
          {
            "name": "outer",
            "in": "query",
            "required": false,
            "schema": {
              "type": "boolean",
              "default": false,
              "title": "Outer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_str_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "get_html"
      }
    },
    "/v1/browser/page/text": {
      "get": {
        "tags": ["browser"],
        "summary": "Get Text",
        "description": "Get all visible text from the page.",
        "operationId": "get_text_v1_browser_page_text_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_str_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "get_text"
      }
    },
    "/v1/browser/page/markdown": {
      "get": {
        "tags": ["browser"],
        "summary": "Get Markdown",
        "description": "Get the page content as Markdown using Readability and Turndown.",
        "operationId": "get_markdown_v1_browser_page_markdown_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_dict_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "get_markdown"
      }
    },
    "/v1/browser/page/elements": {
      "get": {
        "tags": ["browser"],
        "summary": "Get Interactive Elements",
        "description": "Get all interactive elements on the page.",
        "operationId": "get_interactive_elements_v1_browser_page_elements_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_list_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "get_elements"
      }
    },
    "/v1/browser/page/console": {
      "get": {
        "tags": ["browser"],
        "summary": "Get Console Logs",
        "description": "Get captured browser console log messages.",
        "operationId": "get_console_logs_v1_browser_page_console_get",
        "parameters": [
          {
            "name": "clear",
            "in": "query",
            "required": false,
            "schema": {
              "type": "boolean",
              "default": false,
              "title": "Clear"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_list_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "get_console"
      }
    },
    "/v1/browser/page/console/export": {
      "post": {
        "tags": ["browser"],
        "summary": "Export Console Logs",
        "description": "Export console logs to a JSON file.",
        "operationId": "export_console_logs_v1_browser_page_console_export_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ExportConsoleLogsRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "export_console"
      }
    },
    "/v1/browser/page/evaluate": {
      "post": {
        "tags": ["browser"],
        "summary": "Evaluate",
        "description": "Execute JavaScript and return the result.",
        "operationId": "evaluate_v1_browser_page_evaluate_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/EvaluateRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "evaluate"
      }
    },
    "/v1/browser/page/find_text": {
      "post": {
        "tags": ["browser"],
        "summary": "Find Text",
        "description": "Find text occurrences on the page.",
        "operationId": "find_text_v1_browser_page_find_text_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FindTextRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_list_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "find_text"
      }
    },
    "/v1/browser/page/wait": {
      "post": {
        "tags": ["browser"],
        "summary": "Wait",
        "description": "Unified wait: selector, load, url, network_idle, download, function, response, request, or timeout.",
        "operationId": "wait_v1_browser_page_wait_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/app__models__browser_sdk__WaitRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.page",
        "x-fern-sdk-method-name": "wait"
      }
    },
    "/v1/browser/tabs": {
      "get": {
        "tags": ["browser"],
        "summary": "List Tabs",
        "description": "List all open browser tabs.",
        "operationId": "list_tabs_v1_browser_tabs_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_list_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.tabs",
        "x-fern-sdk-method-name": "list"
      },
      "post": {
        "tags": ["browser"],
        "summary": "Create Tab",
        "description": "Create a new browser tab.",
        "operationId": "create_tab_v1_browser_tabs_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreatePageRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.tabs",
        "x-fern-sdk-method-name": "create"
      }
    },
    "/v1/browser/tabs/{index}": {
      "delete": {
        "tags": ["browser"],
        "summary": "Close Tab",
        "description": "Close a browser tab by index.",
        "operationId": "close_tab_v1_browser_tabs__index__delete",
        "parameters": [
          {
            "name": "index",
            "in": "path",
            "required": true,
            "schema": {
              "type": "integer",
              "title": "Index"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.tabs",
        "x-fern-sdk-method-name": "close"
      }
    },
    "/v1/browser/tabs/{index}/activate": {
      "put": {
        "tags": ["browser"],
        "summary": "Activate Tab",
        "description": "Activate (bring to front) a browser tab by index.",
        "operationId": "activate_tab_v1_browser_tabs__index__activate_put",
        "parameters": [
          {
            "name": "index",
            "in": "path",
            "required": true,
            "schema": {
              "type": "integer",
              "title": "Index"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.tabs",
        "x-fern-sdk-method-name": "activate"
      }
    },
    "/v1/browser/cookies": {
      "get": {
        "tags": ["browser"],
        "summary": "Get Cookies",
        "description": "Get browser cookies, optionally filtered by URLs (comma-separated).",
        "operationId": "get_cookies_v1_browser_cookies_get",
        "parameters": [
          {
            "name": "urls",
            "in": "query",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Urls"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_list_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.cookies",
        "x-fern-sdk-method-name": "get_cookies"
      },
      "post": {
        "tags": ["browser"],
        "summary": "Set Cookies",
        "description": "Set browser cookies.",
        "operationId": "set_cookies_v1_browser_cookies_post",
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CookieSetRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.cookies",
        "x-fern-sdk-method-name": "set_cookies"
      },
      "delete": {
        "tags": ["browser"],
        "summary": "Clear Cookies",
        "description": "Clear all browser cookies.",
        "operationId": "clear_cookies_v1_browser_cookies_delete",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.cookies",
        "x-fern-sdk-method-name": "clear_cookies"
      }
    },
    "/v1/browser/state/save": {
      "post": {
        "tags": ["browser"],
        "summary": "Save State",
        "description": "Save browser state (cookies, localStorage, etc.) to a file.",
        "operationId": "save_state_v1_browser_state_save_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/StateSaveRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.state",
        "x-fern-sdk-method-name": "save"
      }
    },
    "/v1/browser/state/load": {
      "post": {
        "tags": ["browser"],
        "summary": "Load State",
        "description": "Load browser state from a previously saved file.",
        "operationId": "load_state_v1_browser_state_load_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/StateLoadRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.state",
        "x-fern-sdk-method-name": "load"
      }
    },
    "/v1/browser/network/headers": {
      "post": {
        "tags": ["browser"],
        "summary": "Set Extra Headers",
        "description": "Set extra HTTP headers for all subsequent requests.",
        "operationId": "set_extra_headers_v1_browser_network_headers_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/HeadersRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.network",
        "x-fern-sdk-method-name": "set_headers"
      }
    },
    "/v1/browser/network/scoped_headers": {
      "post": {
        "tags": ["browser"],
        "summary": "Set Scoped Headers",
        "description": "Set HTTP headers scoped to a specific origin.",
        "operationId": "set_scoped_headers_v1_browser_network_scoped_headers_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ScopedHeadersRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.network",
        "x-fern-sdk-method-name": "set_scoped_headers"
      }
    },
    "/v1/browser/network/route": {
      "post": {
        "tags": ["browser"],
        "summary": "Add Route",
        "description": "Add a network route to mock or abort matching requests.",
        "operationId": "add_route_v1_browser_network_route_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/NetworkRouteRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.network",
        "x-fern-sdk-method-name": "add_route"
      },
      "delete": {
        "tags": ["browser"],
        "summary": "Remove Route",
        "description": "Remove a previously added network route.",
        "operationId": "remove_route_v1_browser_network_route_delete",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/NetworkRouteRemoveRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.network",
        "x-fern-sdk-method-name": "remove_route"
      }
    },
    "/v1/browser/network/requests": {
      "get": {
        "tags": ["browser"],
        "summary": "Get Requests",
        "description": "Get tracked network requests.",
        "operationId": "get_requests_v1_browser_network_requests_get",
        "parameters": [
          {
            "name": "filter",
            "in": "query",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Filter"
            }
          },
          {
            "name": "limit",
            "in": "query",
            "required": false,
            "schema": {
              "type": "integer",
              "default": 100,
              "title": "Limit"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_list_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.network",
        "x-fern-sdk-method-name": "get_requests"
      }
    },
    "/v1/browser/network/export_har": {
      "post": {
        "tags": ["browser"],
        "summary": "Export Har",
        "description": "Export tracked network requests as a HAR file.",
        "operationId": "export_har_v1_browser_network_export_har_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ExportHarRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.network",
        "x-fern-sdk-method-name": "export_har"
      }
    },
    "/v1/browser/captcha/detect": {
      "get": {
        "tags": ["browser"],
        "summary": "Detect Captcha",
        "description": "Detect CAPTCHA on the current page.",
        "operationId": "detect_captcha_v1_browser_captcha_detect_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.captcha",
        "x-fern-sdk-method-name": "detect"
      }
    },
    "/v1/browser/captcha/wait": {
      "post": {
        "tags": ["browser"],
        "summary": "Wait For Captcha",
        "description": "Wait for CAPTCHA to be resolved.",
        "operationId": "wait_for_captcha_v1_browser_captcha_wait_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CaptchaWaitRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_CaptchaWaitResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser.captcha",
        "x-fern-sdk-method-name": "wait"
      }
    },
    "/v1/browser/restart": {
      "post": {
        "tags": ["browser"],
        "summary": "Restart",
        "description": "Restart the browser session.\n\n- **soft** (default): Reconnect the Playwright session only.\n- **hard**: Restart the browser process via supervisorctl, optionally\n  updating URL blocklist/allowlist policies before restart.",
        "operationId": "restart_v1_browser_restart_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "anyOf": [
                  {
                    "$ref": "#/components/schemas/RestartRequest"
                  },
                  {
                    "type": "null"
                  }
                ],
                "title": "Req"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "browser",
        "x-fern-sdk-method-name": "restart"
      }
    },
    "/v1/browser/proxy.pac": {
      "get": {
        "tags": ["browser"],
        "summary": "Get Proxy Pac",
        "description": "Return the current PAC file for proxy split-routing (if configured).",
        "operationId": "get_proxy_pac_v1_browser_proxy_pac_get",
        "responses": {
          "200": {
            "description": "Proxy Auto-Configuration file",
            "content": {
              "application/x-ns-proxy-autoconfig": {}
            }
          }
        },
        "x-fern-sdk-group-name": "browser",
        "x-fern-sdk-method-name": "get_proxy_pac"
      }
    },
    "/v1/code/execute": {
      "post": {
        "tags": ["code"],
        "summary": "Execute Code",
        "description": "Run code through the unified runtime, dispatching to Python, Node.js, or future language executors",
        "operationId": "execute_code_v1_code_execute_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CodeExecuteRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_CodeExecuteResponse_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "code",
        "x-fern-sdk-method-name": "execute_code"
      }
    },
    "/v1/code/info": {
      "get": {
        "tags": ["code"],
        "summary": "Code Info",
        "description": "Return metadata about supported code runtimes\n\nNote: Version info is cached at service level (first call only runs subprocess).",
        "operationId": "code_info_v1_code_info_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_CodeInfoResponse_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "code",
        "x-fern-sdk-method-name": "get_info"
      }
    },
    "/v1/util/convert_to_markdown": {
      "post": {
        "tags": ["util"],
        "summary": "Convert To Markdown",
        "description": "Convert a given URI to Markdown format",
        "operationId": "convert_to_markdown_v1_util_convert_to_markdown_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/UtilConvertToMarkdownRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "util",
        "x-fern-sdk-method-name": "convert_to_markdown"
      }
    },
    "/v1/skills/register": {
      "post": {
        "tags": ["skills"],
        "summary": "Register Skills",
        "operationId": "register_skills",
        "requestBody": {
          "content": {
            "multipart/form-data": {
              "schema": {
                "$ref": "#/components/schemas/Body_register_skills"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_SkillRegistrationResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "skills",
        "x-fern-sdk-method-name": "register_skills"
      }
    },
    "/v1/skills/metadatas": {
      "get": {
        "tags": ["skills"],
        "summary": "List Skills Metadata",
        "operationId": "list_skills_metadata",
        "parameters": [
          {
            "name": "names",
            "in": "query",
            "required": false,
            "schema": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "null"
                }
              ],
              "title": "Names"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_SkillMetadataCollection_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "skills",
        "x-fern-sdk-method-name": "list_metadata"
      }
    },
    "/v1/skills": {
      "delete": {
        "tags": ["skills"],
        "summary": "Clear Skills",
        "operationId": "clear_skills",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_dict_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "skills",
        "x-fern-sdk-method-name": "clear_skills"
      }
    },
    "/v1/skills/{name}": {
      "delete": {
        "tags": ["skills"],
        "summary": "Delete Skill",
        "operationId": "delete_skill",
        "parameters": [
          {
            "name": "name",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Name"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_SkillMetadata_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "skills",
        "x-fern-sdk-method-name": "delete_skill"
      }
    },
    "/v1/skills/{name}/content": {
      "get": {
        "tags": ["skills"],
        "summary": "Get Skill Content",
        "operationId": "get_skill_content",
        "parameters": [
          {
            "name": "name",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Name"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_SkillContentResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "skills",
        "x-fern-sdk-method-name": "get_content"
      }
    },
    "/v1/proxy/mappings": {
      "get": {
        "tags": ["proxy"],
        "summary": "List Mappings",
        "description": "List all proxy domain-to-port mappings.",
        "operationId": "list_proxy_mappings",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_list_ProxyMappingRoute__"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "proxy",
        "x-fern-sdk-method-name": "list_mappings"
      },
      "post": {
        "tags": ["proxy"],
        "summary": "Add Mapping",
        "description": "Add or update a proxy mapping. Supports wildcards in host (*.example.com).",
        "operationId": "add_proxy_mapping",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ProxyMappingAddRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ProxyMappingRoute_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "proxy",
        "x-fern-sdk-method-name": "add_mapping"
      }
    },
    "/v1/proxy/mappings/{source}": {
      "delete": {
        "tags": ["proxy"],
        "summary": "Remove Mapping",
        "description": "Remove a proxy mapping by source pattern.",
        "operationId": "remove_proxy_mapping",
        "parameters": [
          {
            "name": "source",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Source"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "proxy",
        "x-fern-sdk-method-name": "remove_mapping"
      }
    },
    "/v1/proxy/excludes": {
      "get": {
        "tags": ["proxy"],
        "summary": "List Excludes",
        "description": "List all proxy bypass/exclude patterns.",
        "operationId": "list_proxy_excludes",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_list_str__"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "proxy",
        "x-fern-sdk-method-name": "list_excludes"
      },
      "post": {
        "tags": ["proxy"],
        "summary": "Add Exclude",
        "description": "Add a bypass/exclude pattern. Matched domains connect directly.",
        "operationId": "add_proxy_exclude",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ProxyBypassRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "proxy",
        "x-fern-sdk-method-name": "add_exclude"
      },
      "delete": {
        "tags": ["proxy"],
        "summary": "Remove Exclude",
        "description": "Remove a bypass/exclude pattern.",
        "operationId": "remove_proxy_exclude",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ProxyBypassRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "proxy",
        "x-fern-sdk-method-name": "remove_exclude"
      }
    },
    "/v1/proxy/diagnose": {
      "get": {
        "tags": ["proxy"],
        "summary": "Diagnose",
        "description": "Diagnose how a URL would be routed through the proxy.",
        "operationId": "diagnose_proxy",
        "parameters": [
          {
            "name": "url",
            "in": "query",
            "required": true,
            "schema": {
              "type": "string",
              "description": "URL to diagnose routing for",
              "title": "Url"
            },
            "description": "URL to diagnose routing for"
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ProxyDiagnoseResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "proxy",
        "x-fern-sdk-method-name": "diagnose"
      }
    },
    "/v1/proxy/health": {
      "get": {
        "tags": ["proxy"],
        "summary": "Health Check",
        "description": "Check proxy subsystem health: GOST alive, nginx alive, config consistency.",
        "operationId": "proxy_health_check",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ProxyHealthCheck_"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "proxy",
        "x-fern-sdk-method-name": "health"
      }
    },
    "/v1/proxy/upstream": {
      "get": {
        "tags": ["proxy"],
        "summary": "Get Upstream",
        "description": "Get the current upstream proxy configuration.",
        "operationId": "get_proxy_upstream",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_Union_ProxyUpstreamInfo__NoneType__"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "proxy",
        "x-fern-sdk-method-name": "get_upstream"
      },
      "put": {
        "tags": ["proxy"],
        "summary": "Set Upstream",
        "description": "Set or update the upstream proxy. Supports user:pass@host:port format.\n\nTakes effect immediately — no browser restart needed.",
        "operationId": "set_proxy_upstream",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ProxyUpstreamUpdateRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_ProxyUpstreamInfo_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "proxy",
        "x-fern-sdk-method-name": "set_upstream"
      },
      "delete": {
        "tags": ["proxy"],
        "summary": "Remove Upstream",
        "description": "Remove upstream proxy (switch to direct mode).",
        "operationId": "remove_proxy_upstream",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "proxy",
        "x-fern-sdk-method-name": "remove_upstream"
      }
    },
    "/v1/display/record": {
      "post": {
        "tags": ["display"],
        "summary": "Record",
        "description": "Control display screen recording (start/stop/status).\n\nRecords the entire X11 desktop using ffmpeg x11grab,\nincluding browser UI, multiple tabs, popups, terminal, etc.",
        "operationId": "record_v1_display_record_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DisplayRecordRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Response_DisplayRecordResult_"
                }
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "display",
        "x-fern-sdk-method-name": "record"
      }
    },
    "/v1/file/watch": {
      "get": {
        "tags": ["file-watch"],
        "summary": "List Watches",
        "operationId": "list_watches_v1_file_watch_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "watch_list"
      },
      "post": {
        "tags": ["file-watch"],
        "summary": "Create Watch",
        "operationId": "create_watch_v1_file_watch_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/CreateWatchRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "watch_create"
      }
    },
    "/v1/file/watch/{watcher_id}/events": {
      "get": {
        "tags": ["file-watch"],
        "summary": "Watch Events",
        "operationId": "watch_events_v1_file_watch__watcher_id__events_get",
        "parameters": [
          {
            "name": "watcher_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Watcher Id"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "watch_events"
      }
    },
    "/v1/file/watch/{watcher_id}/poll": {
      "post": {
        "tags": ["file-watch"],
        "summary": "Poll Events",
        "operationId": "poll_events_v1_file_watch__watcher_id__poll_post",
        "parameters": [
          {
            "name": "watcher_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Watcher Id"
            }
          }
        ],
        "requestBody": {
          "required": true,
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/PollRequest"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "watch_poll"
      }
    },
    "/v1/file/watch/wait": {
      "post": {
        "tags": ["file-watch"],
        "summary": "Wait For File",
        "operationId": "wait_for_file_v1_file_watch_wait_post",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/app__schemas__file_watch__WaitRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "watch_wait"
      }
    },
    "/v1/file/watch/{watcher_id}": {
      "delete": {
        "tags": ["file-watch"],
        "summary": "Stop Watch",
        "operationId": "stop_watch_v1_file_watch__watcher_id__delete",
        "parameters": [
          {
            "name": "watcher_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string",
              "title": "Watcher Id"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          },
          "422": {
            "description": "Validation Error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/HTTPValidationError"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "file",
        "x-fern-sdk-method-name": "watch_stop"
      }
    },
    "/tickets": {
      "post": {
        "tags": ["auth"],
        "summary": "Create Ticket",
        "description": "Create and return a short-lived authentication ticket.\n\nThis is a non-idempotent action; each call creates a new, unique ticket.",
        "operationId": "create_ticket_tickets_post",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "additionalProperties": true,
                  "type": "object",
                  "title": "Response Create Ticket Tickets Post"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "auth",
        "x-fern-sdk-method-name": "create_ticket"
      }
    },
    "/auth": {
      "get": {
        "tags": ["auth"],
        "summary": "Authenticate Request",
        "description": "Authenticate a request using ticket or JWT.\n\nThis endpoint receives authentication subrequests (e.g., from Nginx auth_request).\nIt validates the request based on either a ticket in the 'x-original-uri'\nheader or a JWT in the 'Authorization' header.",
        "operationId": "authenticate_request_auth_get",
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {
                  "additionalProperties": {
                    "type": "string"
                  },
                  "type": "object",
                  "title": "Response Authenticate Request Auth Get"
                }
              }
            }
          }
        },
        "x-fern-sdk-group-name": "auth",
        "x-fern-sdk-method-name": "authenticate"
      }
    }
  },
  "components": {
    "schemas": {
      "ActionData": {
        "properties": {
          "status": {
            "type": "string",
            "const": "success",
            "title": "Status"
          },
          "action_performed": {
            "type": "string",
            "title": "Action Performed"
          }
        },
        "type": "object",
        "required": ["status", "action_performed"],
        "title": "ActionData",
        "description": "Inner data for action response."
      },
      "ActionResponse": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ActionData"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          },
          "status": {
            "type": "string",
            "const": "success",
            "title": "Status",
            "default": "success"
          },
          "action_performed": {
            "type": "string",
            "title": "Action Performed",
            "default": ""
          }
        },
        "type": "object",
        "title": "ActionResponse",
        "description": "Response model for browser actions.\n\nInherits from Response for unified API format, with backward compatibility:\n- Old format: resp.json()['status'], resp.json()['action_performed']\n- New format: resp.json()['success'], resp.json()['message'], resp.json()['data']"
      },
      "ActiveSessionsResult": {
        "properties": {
          "sessions": {
            "additionalProperties": {
              "$ref": "#/components/schemas/SessionInfo"
            },
            "type": "object",
            "title": "Sessions",
            "description": "Map of session ID to session info"
          }
        },
        "type": "object",
        "required": ["sessions"],
        "title": "ActiveSessionsResult",
        "description": "Active sessions result"
      },
      "ActiveShellSessionsResult": {
        "properties": {
          "sessions": {
            "additionalProperties": {
              "$ref": "#/components/schemas/ShellSessionInfo"
            },
            "type": "object",
            "title": "Sessions",
            "description": "Map of session ID to session info"
          }
        },
        "type": "object",
        "required": ["sessions"],
        "title": "ActiveShellSessionsResult",
        "description": "Active shell sessions result"
      },
      "Annotations": {
        "properties": {
          "audience": {
            "anyOf": [
              {
                "items": {
                  "type": "string",
                  "enum": ["user", "assistant"]
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Audience"
          },
          "priority": {
            "anyOf": [
              {
                "type": "number",
                "maximum": 1,
                "minimum": 0
              },
              {
                "type": "null"
              }
            ],
            "title": "Priority"
          }
        },
        "additionalProperties": true,
        "type": "object",
        "title": "Annotations"
      },
      "AudioContent": {
        "properties": {
          "type": {
            "type": "string",
            "const": "audio",
            "title": "Type"
          },
          "data": {
            "type": "string",
            "title": "Data"
          },
          "mimeType": {
            "type": "string",
            "title": "Mimetype"
          },
          "annotations": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/Annotations"
              },
              {
                "type": "null"
              }
            ]
          },
          "_meta": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Meta"
          }
        },
        "additionalProperties": true,
        "type": "object",
        "required": ["type", "data", "mimeType"],
        "title": "AudioContent",
        "description": "Audio content for a message."
      },
      "AvailableTool": {
        "properties": {
          "name": {
            "type": "string",
            "title": "Name",
            "description": "Tool’s command / binary name"
          },
          "description": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Description",
            "description": "Tool’s functionality description",
            "default": ""
          }
        },
        "type": "object",
        "required": ["name"],
        "title": "AvailableTool",
        "description": "Describe an available command-line tool."
      },
      "BashCommandInfo": {
        "properties": {
          "command_id": {
            "type": "string",
            "title": "Command Id",
            "description": "Unique command identifier"
          },
          "command": {
            "type": "string",
            "title": "Command",
            "description": "The command string"
          },
          "status": {
            "$ref": "#/components/schemas/CommandStatus",
            "description": "Command execution status. Possible values: `pending` (accepted but not started yet; typically internal-only), `running` (still executing), `completed` (process exited and `exit_code` is available; a non-zero shell exit code still uses `completed`), `timed_out` (process was force-killed after `hard_timeout`), `killed` (process was terminated by kill/cleanup or an internal execution failure)."
          },
          "exit_code": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exit Code",
            "description": "Exit code (when completed)"
          }
        },
        "type": "object",
        "required": ["command_id", "command", "status"],
        "title": "BashCommandInfo",
        "description": "Serializable command status info (for API responses)."
      },
      "BashCommandStatus": {
        "type": "string",
        "enum": [
          "running",
          "completed",
          "no_change_timeout",
          "hard_timeout",
          "terminated"
        ],
        "title": "BashCommandStatus",
        "description": "Shell command execution status (compatible with OpenHands)"
      },
      "BashExecRequest": {
        "properties": {
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id",
            "description": "Target session ID. If not provided or empty, a new session is created automatically. Reuse the same session_id to continue the same bash session. Only API-level session state is preserved across calls. Note: `cd` or `export` inside a command do NOT affect subsequent calls."
          },
          "command": {
            "type": "string",
            "title": "Command",
            "description": "Shell command to execute"
          },
          "exec_dir": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exec Dir",
            "description": "Working directory (absolute path). Takes effect on every call — if the session already exists, its default working directory is updated for subsequent calls. Use this instead of `cd` when later commands should run in a different directory."
          },
          "env": {
            "anyOf": [
              {
                "additionalProperties": {
                  "type": "string"
                },
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Env",
            "description": "Extra environment variables to inject for this command only. Variables exported inside the command do not persist to later calls."
          },
          "async_mode": {
            "type": "boolean",
            "title": "Async Mode",
            "description": "If true, return immediately with running status. Use /output to poll results.",
            "default": false
          },
          "timeout": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Timeout",
            "description": "HTTP timeout (seconds). Only effective when async_mode=false. If the command does not complete within this time, HTTP returns running status and the command continues in the background. Use /output to get results."
          },
          "hard_timeout": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hard Timeout",
            "description": "Hard execution timeout (seconds). When reached, the process is killed and status becomes timed_out. None means no limit."
          },
          "max_output_length": {
            "type": "integer",
            "title": "Max Output Length",
            "description": "Maximum character length for stdout/stderr in the response. When output exceeds this limit, middle truncation is applied (head and tail preserved, middle replaced with a marker). Only effective in sync mode (async_mode=false). Set to 0 to disable truncation.",
            "default": 50000
          }
        },
        "type": "object",
        "required": ["command"],
        "title": "BashExecRequest",
        "description": "Request for POST /v1/bash/exec — execute a command."
      },
      "BashExecResult": {
        "properties": {
          "session_id": {
            "type": "string",
            "title": "Session Id",
            "description": "Session identifier"
          },
          "command_id": {
            "type": "string",
            "title": "Command Id",
            "description": "Unique command identifier"
          },
          "command": {
            "type": "string",
            "title": "Command",
            "description": "The executed command"
          },
          "status": {
            "$ref": "#/components/schemas/CommandStatus",
            "description": "Command execution status. Possible values: `pending` (accepted but not started yet; typically internal-only), `running` (still executing), `completed` (process exited and `exit_code` is available; a non-zero shell exit code still uses `completed`), `timed_out` (process was force-killed after `hard_timeout`), `killed` (process was terminated by kill/cleanup or an internal execution failure)."
          },
          "stdout": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Stdout",
            "description": "Stdout output up to this point"
          },
          "stderr": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Stderr",
            "description": "Stderr output up to this point"
          },
          "exit_code": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exit Code",
            "description": "Exit code (when completed)"
          },
          "offset": {
            "type": "integer",
            "title": "Offset",
            "description": "Current stdout offset for subsequent /output calls",
            "default": 0
          },
          "stderr_offset": {
            "type": "integer",
            "title": "Stderr Offset",
            "description": "Current stderr offset",
            "default": 0
          }
        },
        "type": "object",
        "required": ["session_id", "command_id", "command", "status"],
        "title": "BashExecResult",
        "description": "Result of exec_command — returned by POST /v1/bash/exec."
      },
      "BashKillRequest": {
        "properties": {
          "session_id": {
            "type": "string",
            "title": "Session Id",
            "description": "Target session ID"
          },
          "signal": {
            "type": "string",
            "title": "Signal",
            "description": "Signal to send: SIGTERM, SIGKILL, or SIGINT",
            "default": "SIGTERM"
          }
        },
        "type": "object",
        "required": ["session_id"],
        "title": "BashKillRequest",
        "description": "Request for POST /v1/bash/kill — kill a session or its current command."
      },
      "BashOutputRequest": {
        "properties": {
          "session_id": {
            "type": "string",
            "title": "Session Id",
            "description": "Target session ID"
          },
          "command_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Command Id",
            "description": "Target a specific async command. If not set, uses session-level output."
          },
          "offset": {
            "type": "integer",
            "title": "Offset",
            "description": "Stdout byte offset to read from",
            "default": 0
          },
          "stderr_offset": {
            "type": "integer",
            "title": "Stderr Offset",
            "description": "Stderr byte offset to read from",
            "default": 0
          },
          "wait": {
            "type": "boolean",
            "title": "Wait",
            "description": "If true, long-poll until new output is available or wait_timeout is reached.",
            "default": false
          },
          "wait_timeout": {
            "type": "number",
            "title": "Wait Timeout",
            "description": "Max seconds to wait for new output when wait=true.",
            "default": 30
          }
        },
        "type": "object",
        "required": ["session_id"],
        "title": "BashOutputRequest",
        "description": "Request for POST /v1/bash/output — read output with offset."
      },
      "BashOutputResult": {
        "properties": {
          "session_id": {
            "type": "string",
            "title": "Session Id",
            "description": "Session identifier"
          },
          "stdout": {
            "type": "string",
            "title": "Stdout",
            "description": "New stdout data since last offset",
            "default": ""
          },
          "stderr": {
            "type": "string",
            "title": "Stderr",
            "description": "New stderr data since last offset",
            "default": ""
          },
          "offset": {
            "type": "integer",
            "title": "Offset",
            "description": "Current stdout offset (use for next request)",
            "default": 0
          },
          "stderr_offset": {
            "type": "integer",
            "title": "Stderr Offset",
            "description": "Current stderr offset (use for next request)",
            "default": 0
          },
          "command": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/BashCommandInfo"
              },
              {
                "type": "null"
              }
            ],
            "description": "Current or most recent command status"
          }
        },
        "type": "object",
        "required": ["session_id"],
        "title": "BashOutputResult",
        "description": "Result of get_output — returned by POST /v1/bash/output."
      },
      "BashSessionCreateRequest": {
        "properties": {
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id",
            "description": "Session ID. Auto-generated if not provided or empty."
          },
          "exec_dir": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exec Dir",
            "description": "Initial default working directory for the new session (absolute path). Later /exec calls may update it with exec_dir."
          },
          "snapshot_path": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Snapshot Path",
            "description": "Path to a shell snapshot script to source on session init. This is an initialization snapshot only; command-side env changes are not written back after each exec."
          }
        },
        "type": "object",
        "title": "BashSessionCreateRequest",
        "description": "Request for POST /v1/bash/sessions/create — create a new session."
      },
      "BashSessionInfo": {
        "properties": {
          "session_id": {
            "type": "string",
            "title": "Session Id",
            "description": "Session identifier"
          },
          "status": {
            "$ref": "#/components/schemas/SessionStatus",
            "description": "Session status. Possible values: `ready` (session can accept commands), `closed` (session is closed and cannot accept new commands)."
          },
          "working_dir": {
            "type": "string",
            "title": "Working Dir",
            "description": "Working directory"
          },
          "created_at": {
            "type": "string",
            "format": "date-time",
            "title": "Created At",
            "description": "Creation timestamp"
          },
          "last_used_at": {
            "type": "string",
            "format": "date-time",
            "title": "Last Used At",
            "description": "Last used timestamp"
          },
          "current_command": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Current Command",
            "description": "Currently executing command"
          },
          "command_count": {
            "type": "integer",
            "title": "Command Count",
            "description": "Total commands executed",
            "default": 0
          }
        },
        "type": "object",
        "required": [
          "session_id",
          "status",
          "working_dir",
          "created_at",
          "last_used_at"
        ],
        "title": "BashSessionInfo",
        "description": "Session info for listing — returned by GET /v1/bash/sessions."
      },
      "BashWriteRequest": {
        "properties": {
          "session_id": {
            "type": "string",
            "title": "Session Id",
            "description": "Target session ID"
          },
          "command_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Command Id",
            "description": "Target a specific async command. If not set, writes to current command."
          },
          "input": {
            "type": "string",
            "title": "Input",
            "description": "Content to write to the process stdin"
          }
        },
        "type": "object",
        "required": ["session_id", "input"],
        "title": "BashWriteRequest",
        "description": "Request for POST /v1/bash/write — write to stdin."
      },
      "BlobResourceContents": {
        "properties": {
          "uri": {
            "type": "string",
            "minLength": 1,
            "format": "uri",
            "title": "Uri"
          },
          "mimeType": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Mimetype"
          },
          "_meta": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Meta"
          },
          "blob": {
            "type": "string",
            "title": "Blob"
          }
        },
        "additionalProperties": true,
        "type": "object",
        "required": ["uri", "blob"],
        "title": "BlobResourceContents",
        "description": "Binary contents of a resource."
      },
      "Body_register_skills": {
        "properties": {
          "file": {
            "anyOf": [
              {
                "type": "string",
                "format": "binary"
              },
              {
                "type": "null"
              }
            ],
            "title": "File"
          },
          "path": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Path"
          },
          "name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Name"
          }
        },
        "type": "object",
        "title": "Body_register_skills"
      },
      "Body_upload_file": {
        "properties": {
          "file": {
            "type": "string",
            "format": "binary",
            "title": "File"
          },
          "path": {
            "type": "string",
            "title": "Path"
          }
        },
        "type": "object",
        "required": ["file"],
        "title": "Body_upload_file"
      },
      "BrowserConfigRequest": {
        "properties": {
          "resolution": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/Resolution"
              },
              {
                "type": "null"
              }
            ],
            "description": "The desired screen resolution, allowed values are: 1920x1080, 640x480, 1360x768, 1280x720, 800x600, 1024x768, 1280x800, 1920x1200, 1280x960, 1400x1050, 1680x1050, 1280x1024, 1600x1200."
          }
        },
        "type": "object",
        "title": "BrowserConfigRequest",
        "description": "Browser configuration request"
      },
      "BrowserInfoResult": {
        "properties": {
          "user_agent": {
            "type": "string",
            "title": "User Agent",
            "description": "User agent"
          },
          "cdp_url": {
            "type": "string",
            "title": "Cdp Url",
            "description": "Browser CDP URL"
          },
          "vnc_url": {
            "type": "string",
            "title": "Vnc Url",
            "description": "VNC URL"
          },
          "cdp_ui_url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Cdp Ui Url",
            "description": "CDP UI URL (browser-ui)"
          },
          "viewport": {
            "$ref": "#/components/schemas/BrowserViewport",
            "description": "Display size (from xrandr / env vars)"
          },
          "page_viewport": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/BrowserViewport"
              },
              {
                "type": "null"
              }
            ],
            "description": "Actual Chrome page viewport (window.innerWidth/Height via CDP). Smaller than viewport because Chrome UI chrome takes space."
          }
        },
        "type": "object",
        "required": ["user_agent", "cdp_url", "vnc_url", "viewport"],
        "title": "BrowserInfoResult",
        "description": "Browser Info result"
      },
      "BrowserViewport": {
        "properties": {
          "width": {
            "type": "integer",
            "title": "Width",
            "description": "Viewport width"
          },
          "height": {
            "type": "integer",
            "title": "Height",
            "description": "Viewport height"
          }
        },
        "type": "object",
        "required": ["width", "height"],
        "title": "BrowserViewport"
      },
      "CaptchaWaitRequest": {
        "properties": {
          "timeout": {
            "type": "number",
            "title": "Timeout",
            "default": 60
          },
          "poll_interval": {
            "type": "number",
            "title": "Poll Interval",
            "default": 2
          }
        },
        "type": "object",
        "title": "CaptchaWaitRequest"
      },
      "CaptchaWaitResult": {
        "properties": {
          "resolved": {
            "type": "boolean",
            "title": "Resolved"
          }
        },
        "type": "object",
        "required": ["resolved"],
        "title": "CaptchaWaitResult"
      },
      "CheckRequest": {
        "properties": {
          "selector": {
            "type": "string",
            "title": "Selector"
          }
        },
        "type": "object",
        "required": ["selector"],
        "title": "CheckRequest"
      },
      "ClickAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "CLICK",
            "title": "Action Type",
            "default": "CLICK"
          },
          "x": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "X"
          },
          "y": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Y"
          },
          "button": {
            "type": "string",
            "enum": ["left", "right", "middle"],
            "title": "Button",
            "default": "left"
          },
          "num_clicks": {
            "type": "integer",
            "enum": [1, 2, 3],
            "title": "Num Clicks",
            "default": 1
          }
        },
        "type": "object",
        "title": "ClickAction"
      },
      "ClickRequest": {
        "properties": {
          "selector": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Selector"
          },
          "index": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Index"
          },
          "x": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "X"
          },
          "y": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Y"
          },
          "button": {
            "type": "string",
            "title": "Button",
            "default": "left"
          },
          "click_count": {
            "type": "integer",
            "title": "Click Count",
            "default": 1
          }
        },
        "type": "object",
        "title": "ClickRequest"
      },
      "CodeExecuteRequest": {
        "properties": {
          "language": {
            "$ref": "#/components/schemas/Language",
            "description": "Target runtime language"
          },
          "code": {
            "type": "string",
            "title": "Code",
            "description": "Source code to execute"
          },
          "timeout": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 300,
                "minimum": 1
              },
              {
                "type": "null"
              }
            ],
            "title": "Timeout",
            "description": "Execution timeout in seconds"
          },
          "cwd": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Cwd",
            "description": "Current working directory for code execution"
          },
          "stateful": {
            "type": "boolean",
            "title": "Stateful",
            "description": "Enable stateful execution using Jupyter kernel. When True, variables and state persist across requests with the same session_id.",
            "default": false
          },
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id",
            "description": "Session ID for stateful execution. Required when stateful=True to maintain state across requests. Auto-generated if not provided."
          }
        },
        "type": "object",
        "required": ["language", "code"],
        "title": "CodeExecuteRequest",
        "description": "Unified code execution request model"
      },
      "CodeExecuteResponse": {
        "properties": {
          "language": {
            "$ref": "#/components/schemas/Language",
            "description": "Runtime language that executed the code"
          },
          "status": {
            "type": "string",
            "title": "Status",
            "description": "Execution status indicator"
          },
          "outputs": {
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "type": "array",
            "title": "Outputs",
            "description": "Structured execution outputs"
          },
          "code": {
            "type": "string",
            "title": "Code",
            "description": "Echo of executed code"
          },
          "stdout": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Stdout",
            "description": "Captured standard output stream"
          },
          "stderr": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Stderr",
            "description": "Captured standard error stream"
          },
          "exit_code": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exit Code",
            "description": "Process exit code when applicable"
          },
          "traceback": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Traceback",
            "description": "Captured error traceback lines when available"
          },
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id",
            "description": "Session ID for stateful execution (only present when stateful=True)"
          }
        },
        "type": "object",
        "required": ["language", "status", "code"],
        "title": "CodeExecuteResponse",
        "description": "Unified code execution response model"
      },
      "CodeInfoResponse": {
        "properties": {
          "languages": {
            "items": {
              "$ref": "#/components/schemas/CodeLanguageInfo"
            },
            "type": "array",
            "title": "Languages",
            "description": "List of supported languages and metadata"
          }
        },
        "type": "object",
        "required": ["languages"],
        "title": "CodeInfoResponse",
        "description": "Unified code information response"
      },
      "CodeLanguageInfo": {
        "properties": {
          "language": {
            "$ref": "#/components/schemas/Language",
            "description": "Supported language identifier"
          },
          "description": {
            "type": "string",
            "title": "Description",
            "description": "Human readable runtime description"
          },
          "runtime_version": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Runtime Version",
            "description": "Primary runtime version identifier"
          },
          "default_timeout": {
            "type": "integer",
            "maximum": 300,
            "minimum": 1,
            "title": "Default Timeout",
            "description": "Default timeout in seconds",
            "default": 30
          },
          "max_timeout": {
            "type": "integer",
            "maximum": 300,
            "minimum": 1,
            "title": "Max Timeout",
            "description": "Maximum allowed timeout in seconds",
            "default": 300
          },
          "details": {
            "additionalProperties": true,
            "type": "object",
            "title": "Details",
            "description": "Additional runtime specific metadata"
          }
        },
        "type": "object",
        "required": ["language", "description"],
        "title": "CodeLanguageInfo",
        "description": "Metadata about a supported code runtime"
      },
      "CommandStatus": {
        "type": "string",
        "enum": ["pending", "running", "completed", "timed_out", "killed"],
        "title": "CommandStatus",
        "description": "Status of a bash command execution."
      },
      "ConsoleRecord": {
        "properties": {
          "ps1": {
            "type": "string",
            "title": "Ps1",
            "description": "Command prompt"
          },
          "command": {
            "type": "string",
            "title": "Command",
            "description": "Executed command"
          },
          "output": {
            "type": "string",
            "title": "Output",
            "description": "Command output",
            "default": ""
          }
        },
        "type": "object",
        "required": ["ps1", "command"],
        "title": "ConsoleRecord",
        "description": "Shell command console record model"
      },
      "CookieSetRequest": {
        "properties": {
          "cookies": {
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "type": "array",
            "title": "Cookies"
          }
        },
        "type": "object",
        "required": ["cookies"],
        "title": "CookieSetRequest"
      },
      "CreatePageRequest": {
        "properties": {
          "url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Url"
          }
        },
        "type": "object",
        "title": "CreatePageRequest"
      },
      "CreateWatchRequest": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path",
            "description": "Path of the file or directory to watch"
          },
          "recursive": {
            "type": "boolean",
            "title": "Recursive",
            "description": "Whether to recursively watch subdirectories",
            "default": true
          },
          "exclude": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "title": "Exclude",
            "description": "Directory or glob patterns to exclude",
            "default": [
              ".git",
              "node_modules",
              "__pycache__",
              ".venv",
              "*.pyc",
              "*.pyo",
              ".DS_Store",
              "*.swp",
              "*.swo"
            ]
          },
          "debounce": {
            "type": "integer",
            "maximum": 5000,
            "minimum": 50,
            "title": "Debounce",
            "description": "Debounce window in milliseconds",
            "default": 300
          },
          "include_patterns": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "title": "Include Patterns",
            "description": "Glob filters; empty means all events are included",
            "default": []
          }
        },
        "type": "object",
        "required": ["path"],
        "title": "CreateWatchRequest"
      },
      "DependencyCommandResult": {
        "properties": {
          "command": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "title": "Command",
            "description": "Executed dependency command"
          },
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the command succeeded"
          },
          "stdout": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Stdout",
            "description": "Standard output from command"
          },
          "stderr": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Stderr",
            "description": "Standard error from command"
          }
        },
        "type": "object",
        "required": ["command", "success"],
        "title": "DependencyCommandResult"
      },
      "DisplayRecordRequest": {
        "properties": {
          "action": {
            "type": "string",
            "enum": ["start", "stop", "status"],
            "title": "Display Record Action",
            "description": "Recording action: start, stop, or status"
          },
          "save_path": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Save Path",
            "description": "Output file path (default: /tmp/recordings/recording_{timestamp}.mp4)"
          },
          "fps": {
            "type": "integer",
            "maximum": 30,
            "exclusiveMinimum": 0,
            "title": "Fps",
            "description": "Frames per second",
            "default": 5
          },
          "crf": {
            "type": "integer",
            "maximum": 51,
            "minimum": 0,
            "title": "Crf",
            "description": "H.264 CRF quality (0=lossless, 51=worst)",
            "default": 28
          },
          "max_duration": {
            "type": "number",
            "exclusiveMinimum": 0,
            "title": "Max Duration",
            "description": "Max recording duration in seconds",
            "default": 600
          },
          "width": {
            "anyOf": [
              {
                "type": "integer",
                "exclusiveMinimum": 0
              },
              {
                "type": "null"
              }
            ],
            "title": "Width",
            "description": "Video width in pixels (auto-detected from X11 if omitted)"
          },
          "height": {
            "anyOf": [
              {
                "type": "integer",
                "exclusiveMinimum": 0
              },
              {
                "type": "null"
              }
            ],
            "title": "Height",
            "description": "Video height in pixels (auto-detected from X11 if omitted)"
          }
        },
        "type": "object",
        "required": ["action"],
        "title": "DisplayRecordRequest"
      },
      "DisplayRecordResult": {
        "properties": {
          "status": {
            "type": "string",
            "enum": ["idle", "recording", "stopped"],
            "title": "Status"
          },
          "save_path": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Save Path"
          },
          "duration": {
            "type": "number",
            "title": "Duration",
            "default": 0
          },
          "file_size_bytes": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "File Size Bytes"
          }
        },
        "type": "object",
        "required": ["status"],
        "title": "DisplayRecordResult"
      },
      "DoubleClickAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "DOUBLE_CLICK",
            "title": "Action Type",
            "default": "DOUBLE_CLICK"
          },
          "x": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "X"
          },
          "y": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Y"
          }
        },
        "type": "object",
        "title": "DoubleClickAction"
      },
      "DragRelAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "DRAG_REL",
            "title": "Action Type",
            "default": "DRAG_REL"
          },
          "x_offset": {
            "type": "number",
            "title": "X Offset",
            "description": "Relative current position x-axis drag movement"
          },
          "y_offset": {
            "type": "number",
            "title": "Y Offset",
            "description": "Relative current position y-axis drag movement"
          }
        },
        "type": "object",
        "required": ["x_offset", "y_offset"],
        "title": "DragRelAction"
      },
      "DragToAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "DRAG_TO",
            "title": "Action Type",
            "default": "DRAG_TO"
          },
          "x": {
            "type": "number",
            "title": "X",
            "description": "Target x-coordinate for drag"
          },
          "y": {
            "type": "number",
            "title": "Y",
            "description": "Target y-coordinate for drag"
          }
        },
        "type": "object",
        "required": ["x", "y"],
        "title": "DragToAction"
      },
      "EmbeddedResource": {
        "properties": {
          "type": {
            "type": "string",
            "const": "resource",
            "title": "Type"
          },
          "resource": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/TextResourceContents"
              },
              {
                "$ref": "#/components/schemas/BlobResourceContents"
              }
            ],
            "title": "Resource"
          },
          "annotations": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/Annotations"
              },
              {
                "type": "null"
              }
            ]
          },
          "_meta": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Meta"
          }
        },
        "additionalProperties": true,
        "type": "object",
        "required": ["type", "resource"],
        "title": "EmbeddedResource",
        "description": "The contents of a resource, embedded into a prompt or tool call result.\n\nIt is up to the client how best to render embedded resources for the benefit\nof the LLM and/or the user."
      },
      "EvaluateRequest": {
        "properties": {
          "expression": {
            "type": "string",
            "title": "Expression"
          }
        },
        "type": "object",
        "required": ["expression"],
        "title": "EvaluateRequest"
      },
      "ExportConsoleLogsRequest": {
        "properties": {
          "save_path": {
            "type": "string",
            "title": "Save Path"
          },
          "clear": {
            "type": "boolean",
            "title": "Clear",
            "default": false
          }
        },
        "type": "object",
        "required": ["save_path"],
        "title": "ExportConsoleLogsRequest"
      },
      "ExportHarRequest": {
        "properties": {
          "save_path": {
            "type": "string",
            "title": "Save Path"
          }
        },
        "type": "object",
        "required": ["save_path"],
        "title": "ExportHarRequest"
      },
      "FileContentEncoding": {
        "type": "string",
        "enum": ["utf-8", "base64", "raw"],
        "title": "FileContentEncoding",
        "description": "File content encoding type"
      },
      "FileDownloadChangePolicy": {
        "type": "string",
        "enum": ["ignore", "abort"],
        "title": "FileDownloadChangePolicy",
        "description": "How the download endpoint reacts when the source file changes."
      },
      "FileFindRequest": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path",
            "description": "Directory path to search"
          },
          "glob": {
            "type": "string",
            "title": "Glob",
            "description": "Filename pattern (glob syntax)"
          }
        },
        "type": "object",
        "required": ["path", "glob"],
        "title": "FileFindRequest",
        "description": "File find request"
      },
      "FileFindResult": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path",
            "description": "Path of the search directory"
          },
          "files": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "title": "Files",
            "description": "List of found files",
            "default": []
          }
        },
        "type": "object",
        "required": ["path"],
        "title": "FileFindResult",
        "description": "File find result"
      },
      "FileGlobRequest": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path",
            "description": "Base directory path"
          },
          "pattern": {
            "type": "string",
            "title": "Pattern",
            "description": "Glob pattern (**, *, ?, [...])"
          },
          "exclude": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exclude",
            "description": "Glob patterns to exclude"
          },
          "include_hidden": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Include Hidden",
            "description": "Whether to include hidden files",
            "default": false
          },
          "files_only": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Files Only",
            "description": "Only return files (not directories)",
            "default": true
          },
          "include_metadata": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Include Metadata",
            "description": "Whether to include size and modified time",
            "default": true
          },
          "max_results": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 50000,
                "minimum": 1
              },
              {
                "type": "null"
              }
            ],
            "title": "Max Results",
            "description": "Maximum number of results",
            "default": 5000
          },
          "sort_by": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Sort By",
            "description": "Sort by: path, name, size, modified",
            "default": "path"
          },
          "sort_desc": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Sort Desc",
            "description": "Sort in descending order",
            "default": false
          }
        },
        "type": "object",
        "required": ["path", "pattern"],
        "title": "FileGlobRequest",
        "description": "Enhanced file glob request"
      },
      "FileGlobResult": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path",
            "description": "Base directory path"
          },
          "pattern": {
            "type": "string",
            "title": "Pattern",
            "description": "Glob pattern used"
          },
          "files": {
            "items": {
              "$ref": "#/components/schemas/GlobFileInfo"
            },
            "type": "array",
            "title": "Files",
            "description": "List of matched files",
            "default": []
          },
          "total_count": {
            "type": "integer",
            "title": "Total Count",
            "description": "Total number of matches",
            "default": 0
          },
          "truncated": {
            "type": "boolean",
            "title": "Truncated",
            "description": "Whether results were truncated",
            "default": false
          }
        },
        "type": "object",
        "required": ["path", "pattern"],
        "title": "FileGlobResult",
        "description": "Enhanced glob result"
      },
      "FileGrepRequest": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path",
            "description": "File or directory path to search"
          },
          "pattern": {
            "type": "string",
            "title": "Pattern",
            "description": "Search pattern (regex or fixed string)"
          },
          "include": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Include",
            "description": "File glob filters to include (e.g., [\"*.py\", \"*.ts\"])"
          },
          "exclude": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exclude",
            "description": "Glob patterns to exclude (e.g., [\"node_modules\", \"*.min.js\"])"
          },
          "case_insensitive": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Case Insensitive",
            "description": "Case insensitive search",
            "default": false
          },
          "fixed_strings": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Fixed Strings",
            "description": "Treat pattern as literal string, not regex",
            "default": false
          },
          "context_before": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 20,
                "minimum": 0
              },
              {
                "type": "null"
              }
            ],
            "title": "Context Before",
            "description": "Number of lines before each match (-B)",
            "default": 0
          },
          "context_after": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 20,
                "minimum": 0
              },
              {
                "type": "null"
              }
            ],
            "title": "Context After",
            "description": "Number of lines after each match (-A)",
            "default": 0
          },
          "max_results": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 10000,
                "minimum": 1
              },
              {
                "type": "null"
              }
            ],
            "title": "Max Results",
            "description": "Maximum number of matches to return",
            "default": 500
          },
          "max_file_size": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Max File Size",
            "description": "Skip files larger than this size (e.g., 1M, 500K)",
            "default": "1M"
          },
          "multiline": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Multiline",
            "description": "Enable multiline matching where . matches newlines and patterns can span lines (rg -U --multiline-dotall)",
            "default": false
          },
          "offset": {
            "anyOf": [
              {
                "type": "integer",
                "minimum": 0
              },
              {
                "type": "null"
              }
            ],
            "title": "Offset",
            "description": "Skip first N matches before returning results (for pagination)",
            "default": 0
          },
          "type": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Type",
            "description": "File type filter using ripgrep type aliases (e.g., \"py\", \"js\", \"rust\", \"go\"). Maps to rg --type."
          },
          "recursive": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Recursive",
            "description": "Search recursively",
            "default": true
          }
        },
        "type": "object",
        "required": ["path", "pattern"],
        "title": "FileGrepRequest",
        "description": "File grep (multi-file content search) request"
      },
      "FileGrepResult": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path",
            "description": "Search directory path"
          },
          "pattern": {
            "type": "string",
            "title": "Pattern",
            "description": "Search pattern used"
          },
          "matches": {
            "items": {
              "$ref": "#/components/schemas/GrepMatch"
            },
            "type": "array",
            "title": "Matches",
            "description": "List of matches",
            "default": []
          },
          "match_count": {
            "type": "integer",
            "title": "Match Count",
            "description": "Total number of matches",
            "default": 0
          },
          "files_searched": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Files Searched",
            "description": "Number of files searched"
          },
          "files_matched": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Files Matched",
            "description": "Number of files with matches"
          },
          "truncated": {
            "type": "boolean",
            "title": "Truncated",
            "description": "Whether results were truncated",
            "default": false
          }
        },
        "type": "object",
        "required": ["path", "pattern"],
        "title": "FileGrepResult",
        "description": "Multi-file grep result"
      },
      "FileInfo": {
        "properties": {
          "name": {
            "type": "string",
            "title": "Name",
            "description": "File name"
          },
          "path": {
            "type": "string",
            "title": "Path",
            "description": "Full file path"
          },
          "is_directory": {
            "type": "boolean",
            "title": "Is Directory",
            "description": "Whether it's a directory"
          },
          "size": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Size",
            "description": "File size in bytes"
          },
          "modified_time": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Modified Time",
            "description": "Last modified time (ISO format)"
          },
          "permissions": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Permissions",
            "description": "File permissions"
          },
          "extension": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Extension",
            "description": "File extension"
          }
        },
        "type": "object",
        "required": ["name", "path", "is_directory"],
        "title": "FileInfo",
        "description": "File information"
      },
      "FileListRequest": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path",
            "description": "Directory path to list"
          },
          "recursive": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Recursive",
            "description": "Whether to list recursively",
            "default": false
          },
          "show_hidden": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Show Hidden",
            "description": "Whether to show hidden files",
            "default": true
          },
          "file_types": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "File Types",
            "description": "Filter by file extensions (e.g., ['.py', '.txt'])"
          },
          "max_depth": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Max Depth",
            "description": "Maximum depth for recursive listing"
          },
          "include_size": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Include Size",
            "description": "Whether to include file size information",
            "default": true
          },
          "include_permissions": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Include Permissions",
            "description": "Whether to include file permissions",
            "default": false
          },
          "sort_by": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Sort By",
            "description": "Sort by: name, size, modified, type",
            "default": "name"
          },
          "sort_desc": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Sort Desc",
            "description": "Sort in descending order",
            "default": false
          }
        },
        "type": "object",
        "required": ["path"],
        "title": "FileListRequest",
        "description": "File list request"
      },
      "FileListResult": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path",
            "description": "Listed directory path"
          },
          "files": {
            "items": {
              "$ref": "#/components/schemas/FileInfo"
            },
            "type": "array",
            "title": "Files",
            "description": "List of files and directories",
            "default": []
          },
          "total_count": {
            "type": "integer",
            "title": "Total Count",
            "description": "Total number of items",
            "default": 0
          },
          "directory_count": {
            "type": "integer",
            "title": "Directory Count",
            "description": "Number of directories",
            "default": 0
          },
          "file_count": {
            "type": "integer",
            "title": "File Count",
            "description": "Number of files",
            "default": 0
          }
        },
        "type": "object",
        "required": ["path"],
        "title": "FileListResult",
        "description": "File list result"
      },
      "FileOperationError": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path",
            "description": "Path used for the file operation"
          },
          "operation": {
            "type": "string",
            "title": "Operation",
            "description": "File operation name"
          },
          "message": {
            "type": "string",
            "title": "Message",
            "description": "Human-readable error message"
          },
          "error_type": {
            "type": "string",
            "title": "Error Type",
            "description": "Normalized file error category"
          },
          "retryable": {
            "type": "boolean",
            "title": "Retryable",
            "description": "Whether retrying may succeed",
            "default": false
          },
          "errno": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Errno",
            "description": "Original OS errno when available"
          },
          "errno_name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Errno Name",
            "description": "Original OS errno symbolic name when available"
          },
          "exception_type": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exception Type",
            "description": "Original Python exception type when available"
          }
        },
        "type": "object",
        "required": ["path", "operation", "message", "error_type"],
        "title": "FileOperationError",
        "description": "Structured file-tool execution error."
      },
      "FileReadRequest": {
        "properties": {
          "file": {
            "type": "string",
            "title": "File",
            "description": "Absolute file path"
          },
          "start_line": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Start Line",
            "description": "Start line (0-based)"
          },
          "end_line": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "End Line",
            "description": "End line (not inclusive)"
          },
          "sudo": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Sudo",
            "description": "Whether to use sudo privileges",
            "default": false
          }
        },
        "type": "object",
        "required": ["file"],
        "title": "FileReadRequest",
        "description": "File read request"
      },
      "FileReadResult": {
        "properties": {
          "content": {
            "type": "string",
            "title": "Content",
            "description": "File content"
          },
          "file": {
            "type": "string",
            "title": "File",
            "description": "Path of the read file"
          }
        },
        "type": "object",
        "required": ["content", "file"],
        "title": "FileReadResult",
        "description": "File read result"
      },
      "FileReplaceRequest": {
        "properties": {
          "file": {
            "type": "string",
            "title": "File",
            "description": "Absolute file path"
          },
          "old_str": {
            "type": "string",
            "title": "Old Str",
            "description": "Original string to replace"
          },
          "new_str": {
            "type": "string",
            "title": "New Str",
            "description": "New string to replace with"
          },
          "sudo": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Sudo",
            "description": "Whether to use sudo privileges",
            "default": false
          }
        },
        "type": "object",
        "required": ["file", "old_str", "new_str"],
        "title": "FileReplaceRequest",
        "description": "File content replacement request"
      },
      "FileReplaceResult": {
        "properties": {
          "file": {
            "type": "string",
            "title": "File",
            "description": "Path of the operated file"
          },
          "replaced_count": {
            "type": "integer",
            "title": "Replaced Count",
            "description": "Number of replacements",
            "default": 0
          }
        },
        "type": "object",
        "required": ["file"],
        "title": "FileReplaceResult",
        "description": "File content replacement result"
      },
      "FileSearchRequest": {
        "properties": {
          "file": {
            "type": "string",
            "title": "File",
            "description": "Absolute file path"
          },
          "regex": {
            "type": "string",
            "title": "Regex",
            "description": "Regular expression pattern"
          },
          "sudo": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Sudo",
            "description": "Whether to use sudo privileges",
            "default": false
          }
        },
        "type": "object",
        "required": ["file", "regex"],
        "title": "FileSearchRequest",
        "description": "File content search request"
      },
      "FileSearchResult": {
        "properties": {
          "file": {
            "type": "string",
            "title": "File",
            "description": "Path of the searched file"
          },
          "matches": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "title": "Matches",
            "description": "List of matched content",
            "default": []
          },
          "line_numbers": {
            "items": {
              "type": "integer"
            },
            "type": "array",
            "title": "Line Numbers",
            "description": "List of matched line numbers",
            "default": []
          }
        },
        "type": "object",
        "required": ["file"],
        "title": "FileSearchResult",
        "description": "File content search result"
      },
      "FileUploadResult": {
        "properties": {
          "file_path": {
            "type": "string",
            "title": "File Path",
            "description": "Path of the uploaded file"
          },
          "file_size": {
            "type": "integer",
            "title": "File Size",
            "description": "Size of the uploaded file in bytes"
          },
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether upload was successful"
          }
        },
        "type": "object",
        "required": ["file_path", "file_size", "success"],
        "title": "FileUploadResult",
        "description": "File upload result"
      },
      "FileWriteRequest": {
        "properties": {
          "file": {
            "type": "string",
            "title": "File",
            "description": "Absolute file path"
          },
          "content": {
            "type": "string",
            "title": "Content",
            "description": "Content to write (text or base64 encoded for binary)"
          },
          "encoding": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FileContentEncoding"
              },
              {
                "type": "null"
              }
            ],
            "description": "Content encoding: utf-8 for text, base64 for binary data",
            "default": "utf-8"
          },
          "append": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Append",
            "description": "Whether to use append mode",
            "default": false
          },
          "leading_newline": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Leading Newline",
            "description": "Whether to add leading newline (only for text mode)",
            "default": false
          },
          "trailing_newline": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Trailing Newline",
            "description": "Whether to add trailing newline (only for text mode)",
            "default": false
          },
          "sudo": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Sudo",
            "description": "Whether to use sudo privileges",
            "default": false
          }
        },
        "type": "object",
        "required": ["file", "content"],
        "title": "FileWriteRequest",
        "description": "File write request - supports both text and binary content"
      },
      "FileWriteResult": {
        "properties": {
          "file": {
            "type": "string",
            "title": "File",
            "description": "Path of the written file"
          },
          "bytes_written": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Bytes Written",
            "description": "Number of bytes written"
          }
        },
        "type": "object",
        "required": ["file"],
        "title": "FileWriteResult",
        "description": "File write result"
      },
      "FillRequest": {
        "properties": {
          "selector": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Selector"
          },
          "index": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Index"
          },
          "text": {
            "type": "string",
            "title": "Text"
          }
        },
        "type": "object",
        "required": ["text"],
        "title": "FillRequest"
      },
      "FindTextRequest": {
        "properties": {
          "keyword": {
            "type": "string",
            "title": "Keyword"
          }
        },
        "type": "object",
        "required": ["keyword"],
        "title": "FindTextRequest"
      },
      "FormFillRequest": {
        "properties": {
          "items": {
            "items": {
              "additionalProperties": true,
              "type": "object"
            },
            "type": "array",
            "title": "Items"
          }
        },
        "type": "object",
        "required": ["items"],
        "title": "FormFillRequest"
      },
      "GlobFileInfo": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path",
            "description": "Full file path"
          },
          "name": {
            "type": "string",
            "title": "Name",
            "description": "File name"
          },
          "is_directory": {
            "type": "boolean",
            "title": "Is Directory",
            "description": "Whether it's a directory",
            "default": false
          },
          "size": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Size",
            "description": "File size in bytes"
          },
          "modified_time": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Modified Time",
            "description": "Last modified time (ISO format)"
          }
        },
        "type": "object",
        "required": ["path", "name"],
        "title": "GlobFileInfo",
        "description": "Glob matched file info"
      },
      "GrepMatch": {
        "properties": {
          "file": {
            "type": "string",
            "title": "File",
            "description": "File path containing the match"
          },
          "line_number": {
            "type": "integer",
            "title": "Line Number",
            "description": "Line number (1-based)"
          },
          "line_content": {
            "type": "string",
            "title": "Line Content",
            "description": "Content of the matched line"
          },
          "context_before": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Context Before",
            "description": "Lines before the match"
          },
          "context_after": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Context After",
            "description": "Lines after the match"
          }
        },
        "type": "object",
        "required": ["file", "line_number", "line_content"],
        "title": "GrepMatch",
        "description": "Single grep match"
      },
      "HTTPValidationError": {
        "properties": {
          "detail": {
            "items": {
              "$ref": "#/components/schemas/ValidationError"
            },
            "type": "array",
            "title": "Detail"
          }
        },
        "type": "object",
        "title": "HTTPValidationError"
      },
      "HeadersRequest": {
        "properties": {
          "headers": {
            "additionalProperties": {
              "type": "string"
            },
            "type": "object",
            "title": "Headers"
          }
        },
        "type": "object",
        "required": ["headers"],
        "title": "HeadersRequest"
      },
      "HotKeyRequest": {
        "properties": {
          "keys": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "title": "Keys"
          }
        },
        "type": "object",
        "required": ["keys"],
        "title": "HotKeyRequest"
      },
      "HotkeyAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "HOTKEY",
            "title": "Action Type",
            "default": "HOTKEY"
          },
          "keys": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "minItems": 1,
            "title": "Keys"
          }
        },
        "type": "object",
        "required": ["keys"],
        "title": "HotkeyAction"
      },
      "HoverRequest": {
        "properties": {
          "selector": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Selector"
          },
          "x": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "X"
          },
          "y": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Y"
          }
        },
        "type": "object",
        "title": "HoverRequest"
      },
      "Icon": {
        "properties": {
          "src": {
            "type": "string",
            "title": "Src"
          },
          "mimeType": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Mimetype"
          },
          "sizes": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Sizes"
          }
        },
        "additionalProperties": true,
        "type": "object",
        "required": ["src"],
        "title": "Icon",
        "description": "An icon for display in user interfaces."
      },
      "ImageContent": {
        "properties": {
          "type": {
            "type": "string",
            "const": "image",
            "title": "Type"
          },
          "data": {
            "type": "string",
            "title": "Data"
          },
          "mimeType": {
            "type": "string",
            "title": "Mimetype"
          },
          "annotations": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/Annotations"
              },
              {
                "type": "null"
              }
            ]
          },
          "_meta": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Meta"
          }
        },
        "additionalProperties": true,
        "type": "object",
        "required": ["type", "data", "mimeType"],
        "title": "ImageContent",
        "description": "Image content for a message."
      },
      "JupyterCreateSessionRequest": {
        "properties": {
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id",
            "description": "Unique identifier for the session, auto-generated if not provided"
          },
          "kernel_name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Kernel Name",
            "description": "Kernel name: 'python3', 'python3.10', 'python3.11', 'python3.12'. Defaults to the runtime Python version resolved from PYTHON_VERSION."
          },
          "cwd": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Cwd",
            "description": "Current working directory for the session"
          }
        },
        "type": "object",
        "title": "JupyterCreateSessionRequest",
        "description": "Jupyter session creation request model"
      },
      "JupyterCreateSessionResponse": {
        "properties": {
          "session_id": {
            "type": "string",
            "title": "Session Id",
            "description": "Unique identifier of the created session"
          },
          "kernel_name": {
            "type": "string",
            "title": "Kernel Name",
            "description": "Name of the kernel associated with the session"
          },
          "message": {
            "type": "string",
            "title": "Message",
            "description": "Status message about session creation"
          }
        },
        "type": "object",
        "required": ["session_id", "kernel_name", "message"],
        "title": "JupyterCreateSessionResponse",
        "description": "Jupyter session creation response model"
      },
      "JupyterExecuteRequest": {
        "properties": {
          "code": {
            "type": "string",
            "title": "Code",
            "description": "Python code to execute"
          },
          "timeout": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 300,
                "minimum": 1
              },
              {
                "type": "null"
              }
            ],
            "title": "Timeout",
            "description": "Execution timeout in seconds",
            "default": 30
          },
          "kernel_name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Kernel Name",
            "description": "Kernel name: 'python3', 'python3.10', 'python3.11', 'python3.12'. Defaults to the runtime Python version resolved from PYTHON_VERSION."
          },
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id",
            "description": "Session ID to maintain kernel state across requests"
          },
          "cwd": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Cwd",
            "description": "Current working directory for the kernel"
          }
        },
        "type": "object",
        "required": ["code"],
        "title": "JupyterExecuteRequest",
        "description": "Jupyter code execution request model"
      },
      "JupyterExecuteResponse": {
        "properties": {
          "kernel_name": {
            "type": "string",
            "title": "Kernel Name",
            "description": "Name of the kernel used for execution"
          },
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id",
            "description": "Session ID for this kernel instance"
          },
          "status": {
            "type": "string",
            "title": "Status",
            "description": "Execution status: ok, error, or timeout"
          },
          "execution_count": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Execution Count",
            "description": "Execution count from the kernel"
          },
          "outputs": {
            "items": {
              "$ref": "#/components/schemas/JupyterOutput"
            },
            "type": "array",
            "title": "Outputs",
            "description": "List of execution outputs"
          },
          "code": {
            "type": "string",
            "title": "Code",
            "description": "The executed code"
          },
          "msg_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Msg Id",
            "description": "Message ID from Jupyter kernel"
          }
        },
        "type": "object",
        "required": ["kernel_name", "status", "outputs", "code"],
        "title": "JupyterExecuteResponse",
        "description": "Jupyter code execution response model"
      },
      "JupyterInfoResponse": {
        "properties": {
          "default_kernel": {
            "type": "string",
            "title": "Default Kernel",
            "description": "Default kernel name"
          },
          "available_kernels": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "title": "Available Kernels",
            "description": "List of available kernel names"
          },
          "active_sessions": {
            "type": "integer",
            "title": "Active Sessions",
            "description": "Number of active sessions"
          },
          "session_timeout_seconds": {
            "type": "integer",
            "title": "Session Timeout Seconds",
            "description": "Session timeout in seconds"
          },
          "max_sessions": {
            "type": "integer",
            "title": "Max Sessions",
            "description": "Maximum number of concurrent sessions"
          },
          "description": {
            "type": "string",
            "title": "Description",
            "description": "Service description"
          },
          "kernel_detection": {
            "type": "string",
            "title": "Kernel Detection",
            "description": "Kernel detection strategy"
          }
        },
        "type": "object",
        "required": [
          "default_kernel",
          "available_kernels",
          "active_sessions",
          "session_timeout_seconds",
          "max_sessions",
          "description",
          "kernel_detection"
        ],
        "title": "JupyterInfoResponse",
        "description": "Jupyter service information response model"
      },
      "JupyterOutput": {
        "properties": {
          "output_type": {
            "type": "string",
            "title": "Output Type",
            "description": "Type of output: stream, execute_result, display_data, or error"
          },
          "name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Name",
            "description": "Stream name (stdout/stderr) for stream outputs"
          },
          "text": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Text",
            "description": "Text content for stream outputs"
          },
          "data": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Data",
            "description": "Output data for execute_result/display_data"
          },
          "metadata": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Metadata",
            "description": "Output metadata"
          },
          "execution_count": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Execution Count",
            "description": "Execution count for execute_result"
          },
          "ename": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Ename",
            "description": "Error name for error outputs"
          },
          "evalue": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Evalue",
            "description": "Error value for error outputs"
          },
          "traceback": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Traceback",
            "description": "Error traceback for error outputs"
          }
        },
        "type": "object",
        "required": ["output_type"],
        "title": "JupyterOutput",
        "description": "Jupyter execution output model"
      },
      "KeyDownAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "KEY_DOWN",
            "title": "Action Type",
            "default": "KEY_DOWN"
          },
          "key": {
            "type": "string",
            "title": "Key"
          }
        },
        "type": "object",
        "required": ["key"],
        "title": "KeyDownAction"
      },
      "KeyRequest": {
        "properties": {
          "key": {
            "type": "string",
            "title": "Key"
          }
        },
        "type": "object",
        "required": ["key"],
        "title": "KeyRequest"
      },
      "KeyUpAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "KEY_UP",
            "title": "Action Type",
            "default": "KEY_UP"
          },
          "key": {
            "type": "string",
            "title": "Key"
          }
        },
        "type": "object",
        "required": ["key"],
        "title": "KeyUpAction"
      },
      "Language": {
        "type": "string",
        "enum": ["python", "javascript"],
        "title": "Language",
        "description": "Supported programming languages for code execution"
      },
      "MouseDownAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "MOUSE_DOWN",
            "title": "Action Type",
            "default": "MOUSE_DOWN"
          },
          "button": {
            "type": "string",
            "enum": ["left", "right", "middle"],
            "title": "Button",
            "default": "left"
          }
        },
        "type": "object",
        "title": "MouseDownAction"
      },
      "MouseUpAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "MOUSE_UP",
            "title": "Action Type",
            "default": "MOUSE_UP"
          },
          "button": {
            "type": "string",
            "enum": ["left", "right", "middle"],
            "title": "Button",
            "default": "left"
          }
        },
        "type": "object",
        "title": "MouseUpAction"
      },
      "MoveRelAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "MOVE_REL",
            "title": "Action Type",
            "default": "MOVE_REL"
          },
          "x_offset": {
            "type": "number",
            "title": "X Offset",
            "description": "Relative current position x-axis movement"
          },
          "y_offset": {
            "type": "number",
            "title": "Y Offset",
            "description": "Relative current position y-axis movement"
          }
        },
        "type": "object",
        "required": ["x_offset", "y_offset"],
        "title": "MoveRelAction"
      },
      "MoveToAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "MOVE_TO",
            "title": "Action Type",
            "default": "MOVE_TO"
          },
          "x": {
            "type": "number",
            "title": "X",
            "description": "Target x-coordinate"
          },
          "y": {
            "type": "number",
            "title": "Y",
            "description": "Target y-coordinate"
          }
        },
        "type": "object",
        "required": ["x", "y"],
        "title": "MoveToAction"
      },
      "NavigateRequest": {
        "properties": {
          "url": {
            "type": "string",
            "title": "Url"
          },
          "wait_until": {
            "type": "string",
            "enum": ["load", "domcontentloaded", "networkidle", "commit"],
            "title": "Wait Until",
            "default": "load"
          },
          "timeout": {
            "type": "number",
            "title": "Timeout",
            "default": 30
          }
        },
        "type": "object",
        "required": ["url"],
        "title": "NavigateRequest"
      },
      "NetworkRouteRemoveRequest": {
        "properties": {
          "url_pattern": {
            "type": "string",
            "title": "Url Pattern"
          }
        },
        "type": "object",
        "required": ["url_pattern"],
        "title": "NetworkRouteRemoveRequest"
      },
      "NetworkRouteRequest": {
        "properties": {
          "url_pattern": {
            "type": "string",
            "title": "Url Pattern"
          },
          "response": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/RouteResponseModel"
              },
              {
                "type": "null"
              }
            ]
          },
          "abort": {
            "type": "boolean",
            "title": "Abort",
            "default": false
          }
        },
        "type": "object",
        "required": ["url_pattern"],
        "title": "NetworkRouteRequest"
      },
      "NodeJSCreateSessionRequest": {
        "properties": {
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id",
            "description": "Custom session ID (auto-generated if not provided)"
          },
          "cwd": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Cwd",
            "description": "Working directory for the session"
          },
          "max_idle_time": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 86400,
                "minimum": 60
              },
              {
                "type": "null"
              }
            ],
            "title": "Max Idle Time",
            "description": "Maximum idle time in seconds (default 24 hours)",
            "default": 86400
          }
        },
        "type": "object",
        "title": "NodeJSCreateSessionRequest"
      },
      "NodeJSCreateSessionResponse": {
        "properties": {
          "session_id": {
            "type": "string",
            "title": "Session Id",
            "description": "Session ID"
          },
          "created": {
            "type": "boolean",
            "title": "Created",
            "description": "Whether the session was newly created"
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Additional message (e.g., if session already exists)"
          },
          "session": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/NodeJSSessionInfo"
              },
              {
                "type": "null"
              }
            ],
            "description": "Session information (if created)"
          }
        },
        "type": "object",
        "required": ["session_id", "created"],
        "title": "NodeJSCreateSessionResponse"
      },
      "NodeJSDeleteSessionResponse": {
        "properties": {
          "deleted": {
            "type": "boolean",
            "title": "Deleted",
            "description": "Whether the session was deleted"
          }
        },
        "type": "object",
        "required": ["deleted"],
        "title": "NodeJSDeleteSessionResponse"
      },
      "NodeJSExecuteRequest": {
        "properties": {
          "code": {
            "type": "string",
            "title": "Code",
            "description": "JavaScript code to execute"
          },
          "timeout": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 300,
                "minimum": 1
              },
              {
                "type": "null"
              }
            ],
            "title": "Timeout",
            "description": "Execution timeout in seconds",
            "default": 30
          },
          "stdin": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Stdin",
            "description": "Standard input for the process"
          },
          "files": {
            "anyOf": [
              {
                "additionalProperties": {
                  "type": "string"
                },
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Files",
            "description": "Additional files to create in execution directory"
          },
          "stateful": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Stateful",
            "description": "Enable stateful execution with persistent REPL session",
            "default": false
          },
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id",
            "description": "Session ID for stateful execution (reuse existing session)"
          },
          "cwd": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Cwd",
            "description": "Working directory for code execution"
          },
          "version": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Version",
            "description": "Node.js version to use: \"node20\", \"node22\", \"node24\", or aliases \"20\", \"22\", \"24\""
          }
        },
        "type": "object",
        "required": ["code"],
        "title": "NodeJSExecuteRequest"
      },
      "NodeJSExecuteResponse": {
        "properties": {
          "language": {
            "type": "string",
            "const": "javascript",
            "title": "Language",
            "description": "Language that was executed (always 'javascript')"
          },
          "status": {
            "type": "string",
            "title": "Status",
            "description": "Execution status: ok, error, or timeout"
          },
          "execution_count": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Execution Count",
            "description": "Execution count"
          },
          "outputs": {
            "items": {
              "$ref": "#/components/schemas/NodeJSOutput"
            },
            "type": "array",
            "title": "Outputs",
            "description": "List of execution outputs",
            "default": []
          },
          "code": {
            "type": "string",
            "title": "Code",
            "description": "Code that was executed"
          },
          "stdout": {
            "type": "string",
            "title": "Stdout",
            "description": "Standard output",
            "default": ""
          },
          "stderr": {
            "type": "string",
            "title": "Stderr",
            "description": "Standard error",
            "default": ""
          },
          "exit_code": {
            "type": "integer",
            "title": "Exit Code",
            "description": "Process exit code"
          },
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id",
            "description": "Session ID for stateful execution (use this to continue the session)"
          }
        },
        "type": "object",
        "required": ["language", "status", "code", "exit_code"],
        "title": "NodeJSExecuteResponse"
      },
      "NodeJSOutput": {
        "properties": {
          "output_type": {
            "type": "string",
            "title": "Output Type",
            "description": "Type of output: stream, error, or execute_result"
          },
          "name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Name",
            "description": "Stream name (stdout/stderr) for stream outputs"
          },
          "text": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Text",
            "description": "Text content for stream outputs"
          },
          "ename": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Ename",
            "description": "Error name for error outputs"
          },
          "evalue": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Evalue",
            "description": "Error value for error outputs"
          },
          "traceback": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Traceback",
            "description": "Error traceback for error outputs"
          },
          "data": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Data",
            "description": "Data for execute_result outputs"
          },
          "metadata": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Metadata",
            "description": "Metadata for outputs"
          }
        },
        "type": "object",
        "required": ["output_type"],
        "title": "NodeJSOutput"
      },
      "NodeJSPackageInfo": {
        "properties": {
          "name": {
            "type": "string",
            "title": "Name",
            "description": "Package name"
          },
          "version": {
            "type": "string",
            "title": "Version",
            "description": "Package version"
          }
        },
        "type": "object",
        "required": ["name", "version"],
        "title": "NodeJSPackageInfo",
        "description": "Package information"
      },
      "NodeJSRuntimeInfo": {
        "properties": {
          "node_version": {
            "type": "string",
            "title": "Node Version",
            "description": "Node.js version"
          },
          "npm_version": {
            "type": "string",
            "title": "Npm Version",
            "description": "npm version"
          },
          "supported_languages": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "title": "Supported Languages",
            "description": "List of supported languages"
          },
          "description": {
            "type": "string",
            "title": "Description",
            "description": "Service description"
          },
          "runtime_directory": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Runtime Directory",
            "description": "Runtime directory path"
          },
          "global_npm_directory": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Global Npm Directory",
            "description": "Global npm directory path"
          },
          "runtime_packages": {
            "items": {
              "$ref": "#/components/schemas/NodeJSPackageInfo"
            },
            "type": "array",
            "title": "Runtime Packages",
            "description": "Pre-installed runtime packages",
            "default": []
          },
          "global_packages": {
            "items": {
              "$ref": "#/components/schemas/NodeJSPackageInfo"
            },
            "type": "array",
            "title": "Global Packages",
            "description": "Globally installed npm packages",
            "default": []
          },
          "error": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Error",
            "description": "Error message if runtime info retrieval failed"
          },
          "available_versions": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "title": "Available Versions",
            "description": "Available Node.js versions (e.g., node20, node22, node24)",
            "default": []
          },
          "current_version": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Current Version",
            "description": "Currently active Node.js version"
          }
        },
        "type": "object",
        "required": [
          "node_version",
          "npm_version",
          "supported_languages",
          "description"
        ],
        "title": "NodeJSRuntimeInfo",
        "description": "NodeJS runtime information model"
      },
      "NodeJSSessionInfo": {
        "properties": {
          "session_id": {
            "type": "string",
            "title": "Session Id",
            "description": "Session ID"
          },
          "cwd": {
            "type": "string",
            "title": "Cwd",
            "description": "Working directory"
          },
          "created_at": {
            "type": "number",
            "title": "Created At",
            "description": "Session creation timestamp (ms since epoch)"
          },
          "last_used": {
            "type": "number",
            "title": "Last Used",
            "description": "Last activity timestamp (ms since epoch)"
          },
          "max_idle_time": {
            "type": "integer",
            "title": "Max Idle Time",
            "description": "Maximum idle time in milliseconds"
          },
          "age_seconds": {
            "type": "integer",
            "title": "Age Seconds",
            "description": "Seconds since last activity"
          },
          "state": {
            "type": "string",
            "title": "State",
            "description": "Session state: IDLE or EXECUTING"
          }
        },
        "type": "object",
        "required": [
          "session_id",
          "cwd",
          "created_at",
          "last_used",
          "max_idle_time",
          "age_seconds",
          "state"
        ],
        "title": "NodeJSSessionInfo"
      },
      "NodeJSSessionListResponse": {
        "properties": {
          "sessions": {
            "additionalProperties": {
              "$ref": "#/components/schemas/NodeJSSessionInfo"
            },
            "type": "object",
            "title": "Sessions",
            "description": "Map of session ID to session info",
            "default": {}
          }
        },
        "type": "object",
        "title": "NodeJSSessionListResponse"
      },
      "NodeJSSessionResponse": {
        "properties": {
          "session": {
            "$ref": "#/components/schemas/NodeJSSessionInfo",
            "description": "Session information"
          }
        },
        "type": "object",
        "required": ["session"],
        "title": "NodeJSSessionResponse"
      },
      "NodeJSUpdateSessionRequest": {
        "properties": {
          "max_idle_time": {
            "anyOf": [
              {
                "type": "integer",
                "maximum": 86400,
                "minimum": 60
              },
              {
                "type": "null"
              }
            ],
            "title": "Max Idle Time",
            "description": "New maximum idle time in seconds"
          },
          "cwd": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Cwd",
            "description": "New working directory"
          }
        },
        "type": "object",
        "title": "NodeJSUpdateSessionRequest"
      },
      "NodeJSUpdateSessionResponse": {
        "properties": {
          "updated": {
            "type": "boolean",
            "title": "Updated",
            "description": "Whether the update was successful"
          },
          "session": {
            "$ref": "#/components/schemas/NodeJSSessionInfo",
            "description": "Updated session information"
          }
        },
        "type": "object",
        "required": ["updated", "session"],
        "title": "NodeJSUpdateSessionResponse"
      },
      "ObservationCgroupSnapshot": {
        "properties": {
          "cpu_usage_pct": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Cpu Usage Pct"
          },
          "cpu_usage_usec": {
            "type": "integer",
            "title": "Cpu Usage Usec",
            "default": 0
          },
          "cpu_nr_periods": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Cpu Nr Periods"
          },
          "cpu_nr_throttled": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Cpu Nr Throttled"
          },
          "cpu_throttled_usec": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Cpu Throttled Usec"
          },
          "mem_current_bytes": {
            "type": "integer",
            "title": "Mem Current Bytes",
            "default": 0
          },
          "mem_max_bytes": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Mem Max Bytes"
          },
          "mem_usage_pct": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Mem Usage Pct"
          },
          "oom": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Oom"
          },
          "oom_kill": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Oom Kill"
          },
          "memory_anon_bytes": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Memory Anon Bytes"
          },
          "memory_file_bytes": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Memory File Bytes"
          },
          "memory_shmem_bytes": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Memory Shmem Bytes"
          },
          "memory_slab_bytes": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Memory Slab Bytes"
          }
        },
        "type": "object",
        "title": "ObservationCgroupSnapshot"
      },
      "ObservationDiskSnapshot": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path"
          },
          "used_bytes": {
            "type": "integer",
            "title": "Used Bytes"
          },
          "total_bytes": {
            "type": "integer",
            "title": "Total Bytes"
          },
          "free_bytes": {
            "type": "integer",
            "title": "Free Bytes"
          },
          "usage_pct": {
            "type": "number",
            "title": "Usage Pct"
          },
          "inode_used": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Inode Used"
          },
          "inode_total": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Inode Total"
          },
          "inode_usage_pct": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Inode Usage Pct"
          }
        },
        "type": "object",
        "required": [
          "path",
          "used_bytes",
          "total_bytes",
          "free_bytes",
          "usage_pct"
        ],
        "title": "ObservationDiskSnapshot"
      },
      "ObservationEvent": {
        "properties": {
          "ts": {
            "type": "string",
            "format": "date-time",
            "title": "Ts"
          },
          "type": {
            "type": "string",
            "title": "Type"
          },
          "message": {
            "type": "string",
            "title": "Message",
            "default": ""
          },
          "data": {
            "additionalProperties": true,
            "type": "object",
            "title": "Data"
          }
        },
        "type": "object",
        "required": ["ts", "type"],
        "title": "ObservationEvent"
      },
      "ObservationExportResult": {
        "properties": {
          "report_id": {
            "type": "string",
            "title": "Report Id"
          },
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id"
          },
          "reason": {
            "type": "string",
            "title": "Reason",
            "default": "manual"
          },
          "created_at": {
            "type": "string",
            "format": "date-time",
            "title": "Created At"
          },
          "path": {
            "type": "string",
            "title": "Path"
          },
          "size_bytes": {
            "type": "integer",
            "title": "Size Bytes"
          }
        },
        "type": "object",
        "required": ["report_id", "created_at", "path", "size_bytes"],
        "title": "ObservationExportResult"
      },
      "ObservationLiveSnapshot": {
        "properties": {
          "captured_at": {
            "type": "string",
            "format": "date-time",
            "title": "Captured At"
          },
          "mode": {
            "type": "string",
            "enum": ["off", "guardrail", "capture"],
            "title": "ObservationMode"
          },
          "cgroup": {
            "$ref": "#/components/schemas/ObservationCgroupSnapshot"
          },
          "disk": {
            "items": {
              "$ref": "#/components/schemas/ObservationDiskSnapshot"
            },
            "type": "array",
            "title": "Disk"
          },
          "top_processes": {
            "items": {
              "$ref": "#/components/schemas/ObservationProcessSnapshot"
            },
            "type": "array",
            "title": "Top Processes"
          },
          "recent_events": {
            "items": {
              "$ref": "#/components/schemas/ObservationEvent"
            },
            "type": "array",
            "title": "Recent Events"
          }
        },
        "type": "object",
        "required": ["captured_at", "mode", "cgroup"],
        "title": "ObservationLiveSnapshot"
      },
      "ObservationProcessSnapshot": {
        "properties": {
          "pid": {
            "type": "integer",
            "title": "Pid"
          },
          "user": {
            "type": "string",
            "title": "User"
          },
          "comm": {
            "type": "string",
            "title": "Comm"
          },
          "rss_bytes": {
            "type": "integer",
            "title": "Rss Bytes"
          },
          "rss_mib": {
            "type": "number",
            "title": "Rss Mib"
          },
          "cpu_pct": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Cpu Pct"
          },
          "threads": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Threads"
          },
          "fds": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Fds"
          },
          "state": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "State"
          },
          "uptime_sec": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Uptime Sec"
          },
          "ppid": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Ppid"
          }
        },
        "type": "object",
        "required": ["pid", "user", "comm", "rss_bytes", "rss_mib"],
        "title": "ObservationProcessSnapshot"
      },
      "ObservationReportInfo": {
        "properties": {
          "report_id": {
            "type": "string",
            "title": "Report Id"
          },
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id"
          },
          "reason": {
            "type": "string",
            "title": "Reason",
            "default": "manual"
          },
          "created_at": {
            "type": "string",
            "format": "date-time",
            "title": "Created At"
          },
          "path": {
            "type": "string",
            "title": "Path"
          },
          "size_bytes": {
            "type": "integer",
            "title": "Size Bytes"
          }
        },
        "type": "object",
        "required": ["report_id", "created_at", "path", "size_bytes"],
        "title": "ObservationReportInfo"
      },
      "ObservationStartResult": {
        "properties": {
          "session_id": {
            "type": "string",
            "title": "Session Id"
          },
          "mode": {
            "type": "string",
            "enum": ["off", "guardrail", "capture"],
            "title": "ObservationMode"
          },
          "started_at": {
            "type": "string",
            "format": "date-time",
            "title": "Started At"
          },
          "ends_at": {
            "anyOf": [
              {
                "type": "string",
                "format": "date-time"
              },
              {
                "type": "null"
              }
            ],
            "title": "Ends At"
          },
          "interval_seconds": {
            "type": "number",
            "title": "Interval Seconds"
          },
          "runtime_dir": {
            "type": "string",
            "title": "Runtime Dir"
          }
        },
        "type": "object",
        "required": [
          "session_id",
          "mode",
          "started_at",
          "interval_seconds",
          "runtime_dir"
        ],
        "title": "ObservationStartResult"
      },
      "ObservationStatus": {
        "properties": {
          "mode": {
            "type": "string",
            "enum": ["off", "guardrail", "capture"],
            "title": "ObservationMode"
          },
          "running": {
            "type": "boolean",
            "title": "Running"
          },
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id"
          },
          "started_at": {
            "anyOf": [
              {
                "type": "string",
                "format": "date-time"
              },
              {
                "type": "null"
              }
            ],
            "title": "Started At"
          },
          "ends_at": {
            "anyOf": [
              {
                "type": "string",
                "format": "date-time"
              },
              {
                "type": "null"
              }
            ],
            "title": "Ends At"
          },
          "interval_seconds": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Interval Seconds"
          },
          "last_sample_at": {
            "anyOf": [
              {
                "type": "string",
                "format": "date-time"
              },
              {
                "type": "null"
              }
            ],
            "title": "Last Sample At"
          },
          "runtime_dir": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Runtime Dir"
          },
          "report_count": {
            "type": "integer",
            "title": "Report Count",
            "default": 0
          }
        },
        "type": "object",
        "required": ["mode", "running"],
        "title": "ObservationStatus"
      },
      "ObservationStopResult": {
        "properties": {
          "session_id": {
            "type": "string",
            "title": "Session Id"
          },
          "stopped": {
            "type": "boolean",
            "title": "Stopped"
          },
          "report_ready": {
            "type": "boolean",
            "title": "Report Ready"
          }
        },
        "type": "object",
        "required": ["session_id", "stopped", "report_ready"],
        "title": "ObservationStopResult"
      },
      "ObserveExportRequest": {
        "properties": {
          "idempotency_key": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 128
              },
              {
                "type": "null"
              }
            ],
            "title": "Idempotency Key",
            "description": "Optional key for idempotent retries of the same export request"
          },
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id",
            "description": "Optional session id to export"
          },
          "reason": {
            "type": "string",
            "title": "Reason",
            "description": "Export reason",
            "default": "manual"
          }
        },
        "type": "object",
        "title": "ObserveExportRequest"
      },
      "ObserveStartRequest": {
        "properties": {
          "mode": {
            "type": "string",
            "enum": ["guardrail", "capture"],
            "title": "ObserveStartMode",
            "default": "capture"
          },
          "idempotency_key": {
            "anyOf": [
              {
                "type": "string",
                "maxLength": 128
              },
              {
                "type": "null"
              }
            ],
            "title": "Idempotency Key",
            "description": "Optional key for idempotent retries of the same start request"
          },
          "duration_seconds": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Duration Seconds",
            "description": "Optional session duration in seconds"
          },
          "interval_seconds": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Interval Seconds",
            "description": "Sampling interval in seconds"
          },
          "include_processes": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Include Processes",
            "description": "Whether to sample process rows"
          },
          "include_disk": {
            "type": "boolean",
            "title": "Include Disk",
            "description": "Whether to sample disk usage",
            "default": true
          }
        },
        "type": "object",
        "title": "ObserveStartRequest"
      },
      "ObserveStopRequest": {
        "properties": {
          "session_id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Session Id",
            "description": "Optional active session id to stop"
          }
        },
        "type": "object",
        "title": "ObserveStopRequest"
      },
      "PollRequest": {
        "properties": {
          "cursor": {
            "type": "integer",
            "minimum": 0,
            "title": "Cursor",
            "description": "Cursor returned by the previous call; only events with seq > cursor are returned",
            "default": 0
          },
          "limit": {
            "type": "integer",
            "maximum": 1000,
            "minimum": 1,
            "title": "Limit",
            "description": "Maximum number of events to return",
            "default": 100
          },
          "timeout": {
            "type": "integer",
            "maximum": 60,
            "minimum": 0,
            "title": "Timeout",
            "description": "Long-poll wait time in seconds; 0 returns immediately",
            "default": 0
          }
        },
        "type": "object",
        "title": "PollRequest"
      },
      "PressAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "PRESS",
            "title": "Action Type",
            "default": "PRESS"
          },
          "key": {
            "type": "string",
            "title": "Key"
          }
        },
        "type": "object",
        "required": ["key"],
        "title": "PressAction"
      },
      "ProxyBypassRequest": {
        "properties": {
          "pattern": {
            "type": "string",
            "title": "Pattern",
            "description": "Bypass pattern: domain (*.example.com, .example.com) or CIDR (10.0.0.0/8)",
            "examples": ["*.internal.company.com", "10.0.0.0/8", ".byted.org"]
          }
        },
        "type": "object",
        "required": ["pattern"],
        "title": "ProxyBypassRequest"
      },
      "ProxyDiagnoseResult": {
        "properties": {
          "url": {
            "type": "string",
            "title": "Url"
          },
          "matched_mapping": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ProxyMappingRoute"
              },
              {
                "type": "null"
              }
            ]
          },
          "resolved_target": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Resolved Target"
          },
          "target_reachable": {
            "type": "boolean",
            "title": "Target Reachable",
            "default": false
          },
          "route": {
            "type": "string",
            "title": "Route"
          }
        },
        "type": "object",
        "required": ["url", "route"],
        "title": "ProxyDiagnoseResult"
      },
      "ProxyHealthCheck": {
        "properties": {
          "healthy": {
            "type": "boolean",
            "title": "Healthy",
            "description": "Overall health status"
          },
          "gost_alive": {
            "type": "boolean",
            "title": "Gost Alive",
            "description": "GOST proxy process is reachable via API"
          },
          "nginx_alive": {
            "type": "boolean",
            "title": "Nginx Alive",
            "description": "nginx process is running"
          },
          "config_consistent": {
            "type": "boolean",
            "title": "Config Consistent",
            "description": "Domain sets in proxy-map.json, gost-hosts.txt, and nginx conf are consistent"
          },
          "inconsistencies": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "title": "Inconsistencies",
            "description": "List of inconsistency details (empty when config_consistent is true)"
          }
        },
        "type": "object",
        "required": [
          "healthy",
          "gost_alive",
          "nginx_alive",
          "config_consistent"
        ],
        "title": "ProxyHealthCheck"
      },
      "ProxyMappingAddRequest": {
        "properties": {
          "source": {
            "type": "string",
            "title": "Source",
            "description": "Source pattern: [protocol://]host[:port][/path], supports wildcard *",
            "examples": ["myapp.com", "api.myapp.com/v1/*", "*.staging.app.com"]
          },
          "target": {
            "type": "string",
            "title": "Target",
            "description": "Target address: [host:]port[/path]. Host defaults to 127.0.0.1",
            "examples": [":3000", "127.0.0.1:8081/v1/", "192.168.1.5:3000"]
          }
        },
        "type": "object",
        "required": ["source", "target"],
        "title": "ProxyMappingAddRequest"
      },
      "ProxyMappingRoute": {
        "properties": {
          "source": {
            "type": "string",
            "title": "Source",
            "description": "Source pattern: [protocol://]host[:port][/path], supports wildcard * in host",
            "examples": ["myapp.com", "api.myapp.com/v1/*", "*.staging.app.com"]
          },
          "target": {
            "type": "string",
            "title": "Target",
            "description": "Target address: [host:]port[/path]. Host defaults to 127.0.0.1",
            "examples": ["127.0.0.1:3000", ":8081/v1/", "192.168.1.5:3000"]
          },
          "source_host": {
            "type": "string",
            "title": "Source Host",
            "description": "Extracted host from source (used for GOST hosts)"
          },
          "source_path": {
            "type": "string",
            "title": "Source Path",
            "description": "Extracted path from source (used for nginx location)",
            "default": "/"
          },
          "internal_port": {
            "type": "integer",
            "title": "Internal Port",
            "description": "Internal nginx listen port for this domain group"
          }
        },
        "type": "object",
        "required": ["source", "target", "source_host", "internal_port"],
        "title": "ProxyMappingRoute"
      },
      "ProxyUpstreamInfo": {
        "properties": {
          "addr": {
            "type": "string",
            "title": "Addr",
            "description": "Upstream proxy address (host:port)",
            "examples": ["proxy.example.com:3128"]
          },
          "username": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Username",
            "description": "Proxy auth username (if authenticated)"
          },
          "password": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Password",
            "description": "Proxy auth password (if authenticated)"
          }
        },
        "type": "object",
        "required": ["addr"],
        "title": "ProxyUpstreamInfo"
      },
      "ProxyUpstreamUpdateRequest": {
        "properties": {
          "server": {
            "type": "string",
            "title": "Server",
            "description": "Upstream proxy server. Supports plain host:port or user:pass@host:port",
            "examples": [
              "proxy.example.com:3128",
              "user:token@proxy.example.com:8080"
            ]
          },
          "auth_cmd": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Auth Cmd",
            "description": "Optional shell command to obtain proxy credentials. The command stdout should be \"username:password\". When set, the result is injected into the server URL, replacing any inline credentials.",
            "examples": [
              "echo -n \"ZTI_${TCE_PSM}:$(cat $SEC_TOKEN_PATH)\"",
              "/opt/scripts/get-proxy-auth.sh"
            ]
          }
        },
        "type": "object",
        "required": ["server"],
        "title": "ProxyUpstreamUpdateRequest"
      },
      "RecordRequest": {
        "properties": {
          "action": {
            "type": "string",
            "enum": ["once", "start", "pause", "resume", "stop", "status"],
            "title": "Record Action",
            "default": "once"
          },
          "save_path": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Save Path"
          },
          "duration": {
            "type": "number",
            "exclusiveMinimum": 0,
            "title": "Duration",
            "default": 10
          },
          "fps": {
            "type": "integer",
            "exclusiveMinimum": 0,
            "title": "Fps",
            "default": 15
          },
          "quality": {
            "type": "integer",
            "maximum": 100,
            "minimum": 0,
            "title": "Quality",
            "default": 80
          }
        },
        "type": "object",
        "title": "RecordRequest"
      },
      "RegisterHookRequest": {
        "properties": {
          "name": {
            "type": "string",
            "maxLength": 64,
            "pattern": "^[a-zA-Z0-9_-]+$",
            "title": "Name",
            "description": "Unique name for this hook"
          },
          "event": {
            "type": "string",
            "title": "Event",
            "description": "Lifecycle event: \"shutdown\"",
            "default": "shutdown"
          },
          "command": {
            "type": "string",
            "maxLength": 4096,
            "title": "Command",
            "description": "Shell command to execute"
          },
          "timeout": {
            "type": "number",
            "title": "Timeout",
            "description": "Per-hook timeout in seconds",
            "default": 10
          },
          "priority": {
            "type": "integer",
            "title": "Priority",
            "description": "Execution priority (lower = earlier). Same priority hooks run in parallel",
            "default": 100
          }
        },
        "type": "object",
        "required": ["name", "command"],
        "title": "RegisterHookRequest"
      },
      "Resolution": {
        "properties": {
          "width": {
            "type": "integer",
            "exclusiveMinimum": 0,
            "title": "Width",
            "description": "Screen width in pixels."
          },
          "height": {
            "type": "integer",
            "exclusiveMinimum": 0,
            "title": "Height",
            "description": "Screen height in pixels."
          }
        },
        "type": "object",
        "required": ["width", "height"],
        "title": "Resolution"
      },
      "ResourceLink": {
        "properties": {
          "name": {
            "type": "string",
            "title": "Name"
          },
          "title": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Title"
          },
          "uri": {
            "type": "string",
            "minLength": 1,
            "format": "uri",
            "title": "Uri"
          },
          "description": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Description"
          },
          "mimeType": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Mimetype"
          },
          "size": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Size"
          },
          "icons": {
            "anyOf": [
              {
                "items": {
                  "$ref": "#/components/schemas/Icon"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Icons"
          },
          "annotations": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/Annotations"
              },
              {
                "type": "null"
              }
            ]
          },
          "_meta": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Meta"
          },
          "type": {
            "type": "string",
            "const": "resource_link",
            "title": "Type"
          }
        },
        "additionalProperties": true,
        "type": "object",
        "required": ["name", "uri", "type"],
        "title": "ResourceLink",
        "description": "A resource that the server is capable of reading, included in a prompt or tool call result.\n\nNote: resource links returned by tools are not guaranteed to appear in the results of `resources/list` requests."
      },
      "Response": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {},
              {
                "type": "null"
              }
            ],
            "title": "Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response",
        "description": "Generic response model for API interface return results"
      },
      "Response_ActiveSessionsResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ActiveSessionsResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ActiveSessionsResult]"
      },
      "Response_ActiveShellSessionsResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ActiveShellSessionsResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ActiveShellSessionsResult]"
      },
      "Response_BashExecResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/BashExecResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[BashExecResult]"
      },
      "Response_BashOutputResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/BashOutputResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[BashOutputResult]"
      },
      "Response_BashSessionInfo_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/BashSessionInfo"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[BashSessionInfo]"
      },
      "Response_BrowserInfoResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/BrowserInfoResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[BrowserInfoResult]"
      },
      "Response_CallToolResultModel_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "properties": {
                  "_meta": {
                    "anyOf": [
                      {
                        "additionalProperties": true,
                        "type": "object"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "title": "Meta"
                  },
                  "content": {
                    "items": {
                      "anyOf": [
                        {
                          "$ref": "#/components/schemas/TextContent"
                        },
                        {
                          "$ref": "#/components/schemas/ImageContent"
                        },
                        {
                          "$ref": "#/components/schemas/AudioContent"
                        },
                        {
                          "$ref": "#/components/schemas/ResourceLink"
                        },
                        {
                          "$ref": "#/components/schemas/EmbeddedResource"
                        }
                      ]
                    },
                    "type": "array",
                    "title": "Content"
                  },
                  "structuredContent": {
                    "anyOf": [
                      {
                        "additionalProperties": true,
                        "type": "object"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "title": "Structuredcontent"
                  },
                  "isError": {
                    "type": "boolean",
                    "title": "Iserror",
                    "default": false
                  }
                },
                "additionalProperties": true,
                "type": "object",
                "required": ["content"],
                "title": "CallToolResult",
                "description": "The server's response to a tool call."
              },
              {
                "type": "null"
              }
            ],
            "title": "ResponseCallToolResultModel_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[CallToolResultModel]"
      },
      "Response_CaptchaWaitResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/CaptchaWaitResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[CaptchaWaitResult]"
      },
      "Response_CodeExecuteResponse_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/CodeExecuteResponse"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[CodeExecuteResponse]"
      },
      "Response_CodeInfoResponse_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/CodeInfoResponse"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[CodeInfoResponse]"
      },
      "Response_DisplayRecordResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/DisplayRecordResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[DisplayRecordResult]"
      },
      "Response_JupyterCreateSessionResponse_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/JupyterCreateSessionResponse"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[JupyterCreateSessionResponse]"
      },
      "Response_JupyterExecuteResponse_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/JupyterExecuteResponse"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[JupyterExecuteResponse]"
      },
      "Response_JupyterInfoResponse_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/JupyterInfoResponse"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[JupyterInfoResponse]"
      },
      "Response_ListToolsResultModel_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "properties": {
                  "_meta": {
                    "anyOf": [
                      {
                        "additionalProperties": true,
                        "type": "object"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "title": "Meta"
                  },
                  "nextCursor": {
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "title": "Nextcursor"
                  },
                  "tools": {
                    "items": {
                      "$ref": "#/components/schemas/Tool"
                    },
                    "type": "array",
                    "title": "Tools"
                  }
                },
                "additionalProperties": true,
                "type": "object",
                "required": ["tools"],
                "title": "ListToolsResult",
                "description": "The server's response to a tools/list request from the client."
              },
              {
                "type": "null"
              }
            ],
            "title": "ResponseListToolsResultModel_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ListToolsResultModel]"
      },
      "Response_List_str__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "ResponseList_str_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[List[str]]"
      },
      "Response_NodeJSCreateSessionResponse_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/NodeJSCreateSessionResponse"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[NodeJSCreateSessionResponse]"
      },
      "Response_NodeJSDeleteSessionResponse_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/NodeJSDeleteSessionResponse"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[NodeJSDeleteSessionResponse]"
      },
      "Response_NodeJSExecuteResponse_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/NodeJSExecuteResponse"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[NodeJSExecuteResponse]"
      },
      "Response_NodeJSRuntimeInfo_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/NodeJSRuntimeInfo"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[NodeJSRuntimeInfo]"
      },
      "Response_NodeJSSessionListResponse_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/NodeJSSessionListResponse"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[NodeJSSessionListResponse]"
      },
      "Response_NodeJSSessionResponse_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/NodeJSSessionResponse"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[NodeJSSessionResponse]"
      },
      "Response_NodeJSUpdateSessionResponse_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/NodeJSUpdateSessionResponse"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[NodeJSUpdateSessionResponse]"
      },
      "Response_ObservationExportResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ObservationExportResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ObservationExportResult]"
      },
      "Response_ObservationLiveSnapshot_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ObservationLiveSnapshot"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ObservationLiveSnapshot]"
      },
      "Response_ObservationReportInfo_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ObservationReportInfo"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ObservationReportInfo]"
      },
      "Response_ObservationStartResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ObservationStartResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ObservationStartResult]"
      },
      "Response_ObservationStatus_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ObservationStatus"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ObservationStatus]"
      },
      "Response_ObservationStopResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ObservationStopResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ObservationStopResult]"
      },
      "Response_ProxyDiagnoseResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ProxyDiagnoseResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ProxyDiagnoseResult]"
      },
      "Response_ProxyHealthCheck_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ProxyHealthCheck"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ProxyHealthCheck]"
      },
      "Response_ProxyMappingRoute_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ProxyMappingRoute"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ProxyMappingRoute]"
      },
      "Response_ProxyUpstreamInfo_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ProxyUpstreamInfo"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ProxyUpstreamInfo]"
      },
      "Response_SandboxHook_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/SandboxHook"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[SandboxHook]"
      },
      "Response_ShellCommandResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ShellCommandResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ShellCommandResult]"
      },
      "Response_ShellCreateSessionResponse_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ShellCreateSessionResponse"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ShellCreateSessionResponse]"
      },
      "Response_ShellKillResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ShellKillResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ShellKillResult]"
      },
      "Response_ShellSessionStats_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ShellSessionStats"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ShellSessionStats]"
      },
      "Response_ShellViewResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ShellViewResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ShellViewResult]"
      },
      "Response_ShellWaitResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ShellWaitResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ShellWaitResult]"
      },
      "Response_ShellWriteResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ShellWriteResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[ShellWriteResult]"
      },
      "Response_SkillContentResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/SkillContentResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[SkillContentResult]"
      },
      "Response_SkillMetadataCollection_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/SkillMetadataCollection"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[SkillMetadataCollection]"
      },
      "Response_SkillMetadata_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/SkillMetadata"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[SkillMetadata]"
      },
      "Response_SkillRegistrationResult_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/SkillRegistrationResult"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[SkillRegistrationResult]"
      },
      "Response_Union_FileFindResult__FileOperationError__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FileFindResult"
              },
              {
                "$ref": "#/components/schemas/FileOperationError"
              },
              {
                "type": "null"
              }
            ],
            "title": "ResponseUnion_FileFindResult_FileOperationError_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[Union[FileFindResult, FileOperationError]]"
      },
      "Response_Union_FileGlobResult__FileOperationError__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FileGlobResult"
              },
              {
                "$ref": "#/components/schemas/FileOperationError"
              },
              {
                "type": "null"
              }
            ],
            "title": "ResponseUnion_FileGlobResult_FileOperationError_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[Union[FileGlobResult, FileOperationError]]"
      },
      "Response_Union_FileGrepResult__FileOperationError__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FileGrepResult"
              },
              {
                "$ref": "#/components/schemas/FileOperationError"
              },
              {
                "type": "null"
              }
            ],
            "title": "ResponseUnion_FileGrepResult_FileOperationError_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[Union[FileGrepResult, FileOperationError]]"
      },
      "Response_Union_FileListResult__FileOperationError__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FileListResult"
              },
              {
                "$ref": "#/components/schemas/FileOperationError"
              },
              {
                "type": "null"
              }
            ],
            "title": "ResponseUnion_FileListResult_FileOperationError_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[Union[FileListResult, FileOperationError]]"
      },
      "Response_Union_FileReadResult__FileOperationError__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FileReadResult"
              },
              {
                "$ref": "#/components/schemas/FileOperationError"
              },
              {
                "type": "null"
              }
            ],
            "title": "ResponseUnion_FileReadResult_FileOperationError_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[Union[FileReadResult, FileOperationError]]"
      },
      "Response_Union_FileReplaceResult__FileOperationError__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FileReplaceResult"
              },
              {
                "$ref": "#/components/schemas/FileOperationError"
              },
              {
                "type": "null"
              }
            ],
            "title": "ResponseUnion_FileReplaceResult_FileOperationError_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[Union[FileReplaceResult, FileOperationError]]"
      },
      "Response_Union_FileSearchResult__FileOperationError__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FileSearchResult"
              },
              {
                "$ref": "#/components/schemas/FileOperationError"
              },
              {
                "type": "null"
              }
            ],
            "title": "ResponseUnion_FileSearchResult_FileOperationError_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[Union[FileSearchResult, FileOperationError]]"
      },
      "Response_Union_FileUploadResult__FileOperationError__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FileUploadResult"
              },
              {
                "$ref": "#/components/schemas/FileOperationError"
              },
              {
                "type": "null"
              }
            ],
            "title": "ResponseUnion_FileUploadResult_FileOperationError_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[Union[FileUploadResult, FileOperationError]]"
      },
      "Response_Union_FileWriteResult__FileOperationError__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/FileWriteResult"
              },
              {
                "$ref": "#/components/schemas/FileOperationError"
              },
              {
                "type": "null"
              }
            ],
            "title": "ResponseUnion_FileWriteResult_FileOperationError_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[Union[FileWriteResult, FileOperationError]]"
      },
      "Response_Union_ProxyUpstreamInfo__NoneType__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ProxyUpstreamInfo"
              },
              {
                "type": "null"
              }
            ],
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[Union[ProxyUpstreamInfo, NoneType]]"
      },
      "Response_Union_StrReplaceEditorResult__FileOperationError__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/StrReplaceEditorResult"
              },
              {
                "$ref": "#/components/schemas/FileOperationError"
              },
              {
                "type": "null"
              }
            ],
            "title": "ResponseUnion_StrReplaceEditorResult_FileOperationError_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[Union[StrReplaceEditorResult, FileOperationError]]"
      },
      "Response_dict_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Responsedict_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[dict]"
      },
      "Response_list_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "items": {},
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Responselist_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[list]"
      },
      "Response_list_BashSessionInfo__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "items": {
                  "$ref": "#/components/schemas/BashSessionInfo"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Responselist_BashSessionInfo_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[list[BashSessionInfo]]"
      },
      "Response_list_ObservationReportInfo__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "items": {
                  "$ref": "#/components/schemas/ObservationReportInfo"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Responselist_ObservationReportInfo_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[list[ObservationReportInfo]]"
      },
      "Response_list_ProxyMappingRoute__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "items": {
                  "$ref": "#/components/schemas/ProxyMappingRoute"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Responselist_ProxyMappingRoute_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[list[ProxyMappingRoute]]"
      },
      "Response_list_SandboxHook__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "items": {
                  "$ref": "#/components/schemas/SandboxHook"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Responselist_SandboxHook_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[list[SandboxHook]]"
      },
      "Response_list_str__": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Responselist_str_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[list[str]]"
      },
      "Response_str_": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Responsestr_Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          }
        },
        "type": "object",
        "title": "Response[str]"
      },
      "RestartRequest": {
        "properties": {
          "mode": {
            "type": "string",
            "enum": ["soft", "hard"],
            "title": "RestartMode",
            "default": "hard"
          },
          "url_blocklist": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Url Blocklist"
          },
          "url_allowlist": {
            "anyOf": [
              {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Url Allowlist"
          },
          "allow_file_selection_dialogs": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Allow File Selection Dialogs",
            "description": "Control whether web pages can open file picker dialogs. Send null to remove the explicit policy and restore the browser default."
          },
          "locale": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Locale"
          }
        },
        "type": "object",
        "title": "RestartRequest"
      },
      "RightClickAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "RIGHT_CLICK",
            "title": "Action Type",
            "default": "RIGHT_CLICK"
          },
          "x": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "X"
          },
          "y": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Y"
          }
        },
        "type": "object",
        "title": "RightClickAction"
      },
      "RouteResponseModel": {
        "properties": {
          "status": {
            "type": "integer",
            "title": "Status",
            "default": 200
          },
          "headers": {
            "additionalProperties": {
              "type": "string"
            },
            "type": "object",
            "title": "Headers"
          },
          "body": {
            "type": "string",
            "title": "Body",
            "default": ""
          },
          "content_type": {
            "type": "string",
            "title": "Content Type",
            "default": "text/plain"
          }
        },
        "type": "object",
        "title": "RouteResponseModel"
      },
      "RuntimeEnv": {
        "properties": {
          "python": {
            "items": {
              "$ref": "#/components/schemas/ToolSpec"
            },
            "type": "array",
            "title": "Python"
          },
          "nodejs": {
            "items": {
              "$ref": "#/components/schemas/ToolSpec"
            },
            "type": "array",
            "title": "Nodejs"
          }
        },
        "type": "object",
        "required": ["python", "nodejs"],
        "title": "RuntimeEnv",
        "description": "version, path, etc. (python3, python3.11, python3.12, pip3, pip, uv, jupyter)"
      },
      "SandboxDetail": {
        "properties": {
          "system": {
            "$ref": "#/components/schemas/SystemEnv"
          },
          "runtime": {
            "$ref": "#/components/schemas/RuntimeEnv"
          },
          "utils": {
            "items": {
              "$ref": "#/components/schemas/ToolCategory"
            },
            "type": "array",
            "title": "Utils"
          }
        },
        "type": "object",
        "required": ["system", "runtime", "utils"],
        "title": "SandboxDetail",
        "description": "system environment info"
      },
      "SandboxHook": {
        "properties": {
          "name": {
            "type": "string",
            "title": "Name",
            "description": "Unique name for this hook"
          },
          "event": {
            "type": "string",
            "title": "Event",
            "description": "Lifecycle event: \"shutdown\"",
            "default": "shutdown"
          },
          "command": {
            "type": "string",
            "maxLength": 4096,
            "title": "Command",
            "description": "Shell command to execute"
          },
          "timeout": {
            "type": "number",
            "title": "Timeout",
            "description": "Per-hook timeout in seconds",
            "default": 10
          },
          "priority": {
            "type": "integer",
            "title": "Priority",
            "description": "Execution priority (lower = earlier). Same priority hooks run in parallel",
            "default": 100
          },
          "source": {
            "type": "string",
            "title": "Source",
            "description": "Registration source: \"env\" or \"api\"",
            "default": "api"
          }
        },
        "type": "object",
        "required": ["name", "command"],
        "title": "SandboxHook",
        "description": "A registered lifecycle hook."
      },
      "SandboxResponse": {
        "properties": {
          "success": {
            "type": "boolean",
            "title": "Success",
            "description": "Whether the operation was successful",
            "default": true
          },
          "message": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Message",
            "description": "Operation result message",
            "default": "Operation successful"
          },
          "data": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Data",
            "description": "Data returned from the operation"
          },
          "hint": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hint",
            "description": "Context hint for AI agents (e.g. tab changes)"
          },
          "home_dir": {
            "type": "string",
            "title": "Home Dir"
          },
          "workspace": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Workspace"
          },
          "version": {
            "type": "string",
            "title": "Version"
          },
          "detail": {
            "$ref": "#/components/schemas/SandboxDetail"
          }
        },
        "type": "object",
        "required": ["home_dir", "version", "detail"],
        "title": "SandboxResponse"
      },
      "ScopedHeadersRequest": {
        "properties": {
          "origin": {
            "type": "string",
            "title": "Origin"
          },
          "headers": {
            "additionalProperties": {
              "type": "string"
            },
            "type": "object",
            "title": "Headers"
          }
        },
        "type": "object",
        "required": ["origin", "headers"],
        "title": "ScopedHeadersRequest"
      },
      "ScrollAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "SCROLL",
            "title": "Action Type",
            "default": "SCROLL"
          },
          "dx": {
            "type": "integer",
            "title": "Dx",
            "default": 0
          },
          "dy": {
            "type": "integer",
            "title": "Dy",
            "default": 0
          }
        },
        "type": "object",
        "title": "ScrollAction"
      },
      "ScrollRequest": {
        "properties": {
          "direction": {
            "type": "string",
            "title": "Direction",
            "default": "down"
          },
          "amount": {
            "type": "integer",
            "title": "Amount",
            "default": 300
          }
        },
        "type": "object",
        "title": "ScrollRequest"
      },
      "ScrollToElementRequest": {
        "properties": {
          "selector": {
            "type": "string",
            "title": "Selector"
          }
        },
        "type": "object",
        "required": ["selector"],
        "title": "ScrollToElementRequest"
      },
      "ScrollToRequest": {
        "properties": {
          "x": {
            "type": "integer",
            "title": "X",
            "default": 0
          },
          "y": {
            "type": "integer",
            "title": "Y",
            "default": 0
          }
        },
        "type": "object",
        "title": "ScrollToRequest"
      },
      "SelectOptionRequest": {
        "properties": {
          "selector": {
            "type": "string",
            "title": "Selector"
          },
          "value": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Value"
          },
          "label": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Label"
          },
          "index": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Index"
          }
        },
        "type": "object",
        "required": ["selector"],
        "title": "SelectOptionRequest"
      },
      "SessionInfo": {
        "properties": {
          "kernel_name": {
            "type": "string",
            "title": "Kernel Name",
            "description": "Kernel name"
          },
          "last_used": {
            "type": "number",
            "title": "Last Used",
            "description": "Last used timestamp"
          },
          "age_seconds": {
            "type": "integer",
            "title": "Age Seconds",
            "description": "Age of session in seconds"
          }
        },
        "type": "object",
        "required": ["kernel_name", "last_used", "age_seconds"],
        "title": "SessionInfo",
        "description": "Active session information"
      },
      "SessionStatus": {
        "type": "string",
        "enum": ["ready", "closed"],
        "title": "SessionStatus",
        "description": "Status of a pipe bash session."
      },
      "ShellCommandResult": {
        "properties": {
          "session_id": {
            "type": "string",
            "title": "Session Id",
            "description": "Shell session ID"
          },
          "command": {
            "type": "string",
            "title": "Command",
            "description": "Executed command"
          },
          "status": {
            "$ref": "#/components/schemas/BashCommandStatus",
            "description": "Command execution status"
          },
          "output": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Output",
            "description": "Command execution output, only has value when status is completed"
          },
          "console": {
            "anyOf": [
              {
                "items": {
                  "$ref": "#/components/schemas/ConsoleRecord"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Console",
            "description": "Console command records"
          },
          "exit_code": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exit Code",
            "description": "Command execution exit code, only has value when status is completed"
          }
        },
        "type": "object",
        "required": ["session_id", "command", "status"],
        "title": "ShellCommandResult",
        "description": "Shell command execution result model"
      },
      "ShellCreateSessionRequest": {
        "properties": {
          "id": {
            "type": "string",
            "title": "Id",
            "description": "Unique identifier for the shell session, auto-generated if not provided"
          },
          "exec_dir": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exec Dir",
            "description": "Working directory for the new session (must use absolute path)"
          },
          "no_change_timeout": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "No Change Timeout",
            "description": "Timeout (seconds) for detecting no new output from commands in this session. Default is 120 seconds. If no output change is detected within this time, command returns with NO_CHANGE_TIMEOUT status."
          },
          "preserve_symlinks": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Preserve Symlinks",
            "description": "If True, preserve symlinks in working directory path (pwd shows symlink path). If False, symlinks are resolved to physical paths. Defaults to False for backward compatibility.",
            "default": false
          }
        },
        "type": "object",
        "title": "ShellCreateSessionRequest",
        "description": "Shell session creation request model"
      },
      "ShellCreateSessionResponse": {
        "properties": {
          "session_id": {
            "type": "string",
            "title": "Session Id",
            "description": "Unique identifier of the created shell session"
          },
          "working_dir": {
            "type": "string",
            "title": "Working Dir",
            "description": "Working directory of the created session"
          }
        },
        "type": "object",
        "required": ["session_id", "working_dir"],
        "title": "ShellCreateSessionResponse",
        "description": "Shell session creation response model"
      },
      "ShellExecRequest": {
        "properties": {
          "id": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Id",
            "description": "Unique identifier of the target shell session, if not provided, one will be automatically created"
          },
          "exec_dir": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exec Dir",
            "description": "Working directory for command execution (must use absolute path)"
          },
          "command": {
            "type": "string",
            "title": "Command",
            "description": "Shell command to execute"
          },
          "async_mode": {
            "type": "boolean",
            "title": "Async Mode",
            "description": "Whether to execute command asynchronously (default: False for async, False for synchronous execution)",
            "default": false
          },
          "timeout": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Timeout",
            "description": "Maximum time (seconds) to wait for command completion before returning running status"
          },
          "strict": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Strict",
            "description": "Strict mode for working directory validation. If True, returns error when working directory does not exist. If False or None, silently falls back to session working directory."
          },
          "no_change_timeout": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "No Change Timeout",
            "description": "Timeout (seconds) for detecting no new output from a command. If no output change is detected within this time, command returns with NO_CHANGE_TIMEOUT status. Overrides session-level setting for this command only."
          },
          "hard_timeout": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Hard Timeout",
            "description": "Hard timeout (seconds) for command execution. When reached, the command is forcefully stopped and current console output is returned with HARD_TIMEOUT status. Unlike timeout (which only affects HTTP response timing), this actually terminates the command."
          },
          "preserve_symlinks": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Preserve Symlinks",
            "description": "If True, preserve symlinks in working directory path (pwd shows symlink path). If False, symlinks are resolved to physical paths. Defaults to False for backward compatibility.",
            "default": false
          },
          "truncate": {
            "type": "boolean",
            "title": "Truncate",
            "description": "If True, truncate output when it exceeds 30000 characters (default: True)",
            "default": true
          }
        },
        "type": "object",
        "required": ["command"],
        "title": "ShellExecRequest",
        "description": "Shell command execution request model"
      },
      "ShellKillProcessRequest": {
        "properties": {
          "id": {
            "type": "string",
            "title": "Id",
            "description": "Unique identifier of the target shell session"
          }
        },
        "type": "object",
        "required": ["id"],
        "title": "ShellKillProcessRequest",
        "description": "Request model for terminating a running process"
      },
      "ShellKillResult": {
        "properties": {
          "status": {
            "$ref": "#/components/schemas/BashCommandStatus",
            "description": "Process status"
          },
          "exit_code": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exit Code",
            "description": "Process exit code before termination, None if process was still running"
          },
          "returncode": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Returncode",
            "description": "Deprecated: use exit_code instead. Kept for backward compatibility."
          }
        },
        "type": "object",
        "required": ["status"],
        "title": "ShellKillResult",
        "description": "Process termination result model"
      },
      "ShellSessionInfo": {
        "properties": {
          "working_dir": {
            "type": "string",
            "title": "Working Dir",
            "description": "Working directory"
          },
          "created_at": {
            "type": "string",
            "format": "date-time",
            "title": "Created At",
            "description": "Creation timestamp"
          },
          "last_used_at": {
            "type": "string",
            "format": "date-time",
            "title": "Last Used At",
            "description": "Last used timestamp"
          },
          "age_seconds": {
            "type": "integer",
            "title": "Age Seconds",
            "description": "Age of session in seconds"
          },
          "status": {
            "type": "string",
            "title": "Status",
            "description": "Session status"
          },
          "current_command": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Current Command",
            "description": "Currently executing command"
          }
        },
        "type": "object",
        "required": [
          "working_dir",
          "created_at",
          "last_used_at",
          "age_seconds",
          "status"
        ],
        "title": "ShellSessionInfo",
        "description": "Shell session information"
      },
      "ShellSessionStats": {
        "properties": {
          "total_sessions": {
            "type": "integer",
            "title": "Total Sessions",
            "description": "Total number of sessions"
          },
          "active_sessions": {
            "type": "integer",
            "title": "Active Sessions",
            "description": "Number of active sessions (used within last 5 minutes)"
          },
          "idle_sessions": {
            "type": "integer",
            "title": "Idle Sessions",
            "description": "Number of idle sessions"
          },
          "max_sessions": {
            "type": "integer",
            "title": "Max Sessions",
            "description": "Maximum allowed sessions"
          },
          "session_timeout": {
            "type": "integer",
            "title": "Session Timeout",
            "description": "Session timeout in seconds"
          },
          "usage_ratio": {
            "type": "number",
            "title": "Usage Ratio",
            "description": "Session usage ratio (0.0 to 1.0)"
          }
        },
        "type": "object",
        "required": [
          "total_sessions",
          "active_sessions",
          "idle_sessions",
          "max_sessions",
          "session_timeout",
          "usage_ratio"
        ],
        "title": "ShellSessionStats",
        "description": "Shell session statistics model"
      },
      "ShellUpdateSessionRequest": {
        "properties": {
          "id": {
            "type": "string",
            "title": "Id",
            "description": "Unique identifier of the target shell session"
          },
          "no_change_timeout": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "No Change Timeout",
            "description": "New timeout (seconds) for detecting no new output from commands. If no output change is detected within this time, command returns with NO_CHANGE_TIMEOUT status."
          }
        },
        "type": "object",
        "required": ["id"],
        "title": "ShellUpdateSessionRequest",
        "description": "Shell session update request model"
      },
      "ShellViewRequest": {
        "properties": {
          "id": {
            "type": "string",
            "title": "Id",
            "description": "Unique identifier of the target shell session"
          }
        },
        "type": "object",
        "required": ["id"],
        "title": "ShellViewRequest",
        "description": "Shell session content view request model"
      },
      "ShellViewResult": {
        "properties": {
          "output": {
            "type": "string",
            "title": "Output",
            "description": "Shell session output content"
          },
          "session_id": {
            "type": "string",
            "title": "Session Id",
            "description": "Shell session ID"
          },
          "console": {
            "anyOf": [
              {
                "items": {
                  "$ref": "#/components/schemas/ConsoleRecord"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Console",
            "description": "Console command records"
          },
          "status": {
            "$ref": "#/components/schemas/BashCommandStatus",
            "description": "Shell session status"
          },
          "command": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Command",
            "description": "Last executed or currently executing command"
          },
          "exit_code": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Exit Code",
            "description": "Command execution exit code, only has value when status is completed"
          }
        },
        "type": "object",
        "required": ["output", "session_id", "status"],
        "title": "ShellViewResult",
        "description": "Shell session content view result model"
      },
      "ShellWaitRequest": {
        "properties": {
          "id": {
            "type": "string",
            "title": "Id",
            "description": "Unique identifier of the target shell session"
          },
          "seconds": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Seconds",
            "description": "Wait time (seconds)"
          },
          "max_wait_seconds": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Max Wait Seconds",
            "description": "Maximum wait time (seconds) for the command to complete"
          }
        },
        "type": "object",
        "required": ["id"],
        "title": "ShellWaitRequest",
        "description": "Shell process wait request model"
      },
      "ShellWaitResult": {
        "properties": {
          "status": {
            "$ref": "#/components/schemas/BashCommandStatus",
            "description": "Process status"
          }
        },
        "type": "object",
        "required": ["status"],
        "title": "ShellWaitResult",
        "description": "Process wait result model"
      },
      "ShellWriteResult": {
        "properties": {
          "status": {
            "$ref": "#/components/schemas/BashCommandStatus",
            "description": "Write status"
          }
        },
        "type": "object",
        "required": ["status"],
        "title": "ShellWriteResult",
        "description": "Process input write result model"
      },
      "ShellWriteToProcessRequest": {
        "properties": {
          "id": {
            "type": "string",
            "title": "Id",
            "description": "Unique identifier of the target shell session"
          },
          "input": {
            "type": "string",
            "title": "Input",
            "description": "Input content to write to the process"
          },
          "press_enter": {
            "type": "boolean",
            "title": "Press Enter",
            "description": "Whether to press enter key after input"
          }
        },
        "type": "object",
        "required": ["id", "input", "press_enter"],
        "title": "ShellWriteToProcessRequest",
        "description": "Request model for writing input to a running process"
      },
      "SkillContentResult": {
        "properties": {
          "name": {
            "type": "string",
            "title": "Name",
            "description": "Skill name"
          },
          "path": {
            "type": "string",
            "title": "Path",
            "description": "Absolute path to the skill directory"
          },
          "content": {
            "type": "string",
            "title": "Content",
            "description": "Skill content excluding front matter"
          }
        },
        "type": "object",
        "required": ["name", "path", "content"],
        "title": "SkillContentResult"
      },
      "SkillMetadata": {
        "properties": {
          "name": {
            "type": "string",
            "title": "Name",
            "description": "Skill name"
          },
          "path": {
            "type": "string",
            "title": "Path",
            "description": "Absolute path to the skill directory"
          },
          "metadata": {
            "additionalProperties": true,
            "type": "object",
            "title": "Metadata",
            "description": "Metadata parsed from SKILL.md front matter"
          },
          "dependency_commands": {
            "items": {
              "$ref": "#/components/schemas/DependencyCommandResult"
            },
            "type": "array",
            "title": "Dependency Commands",
            "description": "Dependency commands for the skill"
          }
        },
        "type": "object",
        "required": ["name", "path"],
        "title": "SkillMetadata"
      },
      "SkillMetadataCollection": {
        "properties": {
          "skills": {
            "items": {
              "$ref": "#/components/schemas/SkillMetadata"
            },
            "type": "array",
            "title": "Skills",
            "description": "Collection of skill metadata entries"
          }
        },
        "type": "object",
        "title": "SkillMetadataCollection"
      },
      "SkillRegistrationResult": {
        "properties": {
          "count": {
            "type": "integer",
            "title": "Count",
            "description": "Number of registered skills"
          },
          "registered": {
            "items": {
              "$ref": "#/components/schemas/SkillMetadata"
            },
            "type": "array",
            "title": "Registered",
            "description": "Registered skills and metadata"
          }
        },
        "type": "object",
        "required": ["count"],
        "title": "SkillRegistrationResult"
      },
      "StateLoadRequest": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path"
          }
        },
        "type": "object",
        "required": ["path"],
        "title": "StateLoadRequest"
      },
      "StateSaveRequest": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path"
          }
        },
        "type": "object",
        "required": ["path"],
        "title": "StateSaveRequest"
      },
      "StrReplaceEditorRequest": {
        "properties": {
          "command": {
            "type": "string",
            "enum": ["view", "create", "str_replace", "insert", "undo_edit"],
            "title": "Command",
            "description": "The commands to run. Allowed options are: `view`, `create`, `str_replace`, `insert`, `undo_edit`."
          },
          "path": {
            "type": "string",
            "title": "Path",
            "description": "Absolute path to file or directory, e.g. `/workspace/file.py` or `/workspace`."
          },
          "file_text": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "File Text",
            "description": "Required parameter of `create` command, with the content of the file to be created."
          },
          "old_str": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Old Str",
            "description": "Required parameter of `str_replace` command containing the string in `path` to replace."
          },
          "new_str": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "New Str",
            "description": "Optional parameter of `str_replace` command containing the new string (if not given, no string will be added). Required parameter of `insert` command containing the string to insert."
          },
          "insert_line": {
            "anyOf": [
              {
                "type": "integer"
              },
              {
                "type": "null"
              }
            ],
            "title": "Insert Line",
            "description": "Required parameter of `insert` command. The `new_str` will be inserted AFTER the line `insert_line` of `path`."
          },
          "view_range": {
            "anyOf": [
              {
                "items": {
                  "type": "integer"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "View Range",
            "description": "Optional parameter of `view` command when `path` points to a file. If none is given, the full file is shown. If provided, the file will be shown in the indicated line number range, e.g. [11, 12] will show lines 11 and 12. Indexing at 1 to start. Setting `[start_line, -1]` shows all lines from `start_line` to the end of the file.",
            "default": []
          },
          "replace_mode": {
            "anyOf": [
              {
                "type": "string",
                "enum": ["ALL", "FIRST", "LAST"]
              },
              {
                "type": "null"
              }
            ],
            "title": "Replace Mode",
            "description": "Optional parameter of `str_replace` command. When specified, controls how multiple occurrences are handled: 'ALL' replaces all occurrences, 'FIRST' replaces only the first, 'LAST' replaces only the last. If not specified, requires unique match (original behavior)."
          },
          "page_range": {
            "anyOf": [
              {
                "items": {
                  "type": "integer"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Page Range",
            "description": "Optional parameter for `view` command on PDF files. Specifies page range [start, end] (1-indexed). E.g., [1, 5] reads pages 1-5."
          },
          "sheet_name": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Sheet Name",
            "description": "Optional parameter for `view` command on Excel files. Specifies which sheet to read. If not provided, all sheets are returned."
          },
          "row_range": {
            "anyOf": [
              {
                "items": {
                  "type": "integer"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Row Range",
            "description": "Optional parameter for `view` command on Excel files. Specifies row range [start, end] (1-indexed). E.g., [1, 100] reads rows 1-100."
          },
          "slide_range": {
            "anyOf": [
              {
                "items": {
                  "type": "integer"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Slide Range",
            "description": "Optional parameter for `view` command on PPTX files. Specifies slide range [start, end] (1-indexed). E.g., [1, 5] reads slides 1-5."
          },
          "enable_metadata": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Enable Metadata",
            "description": "Optional parameter for `view` command. If true, returns file metadata (total pages, sheets, slides, etc.) in the response.",
            "default": false
          }
        },
        "type": "object",
        "required": ["command", "path"],
        "title": "StrReplaceEditorRequest",
        "description": "String replace editor request based on openhands_aci"
      },
      "StrReplaceEditorResult": {
        "properties": {
          "output": {
            "type": "string",
            "title": "Output",
            "description": "Command execution output"
          },
          "error": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Error",
            "description": "Error message if any"
          },
          "path": {
            "type": "string",
            "title": "Path",
            "description": "File path that was operated on"
          },
          "prev_exist": {
            "type": "boolean",
            "title": "Prev Exist",
            "description": "Whether the file existed before operation"
          },
          "old_content": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Old Content",
            "description": "Previous file content"
          },
          "new_content": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "New Content",
            "description": "New file content after operation"
          },
          "metadata": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "description": "File metadata (only returned when enable_metadata=true for binary files)"
          }
        },
        "type": "object",
        "required": ["output", "path", "prev_exist"],
        "title": "StrReplaceEditorResult",
        "description": "String replace editor result based on openhands_aci CLIResult"
      },
      "SystemEnv": {
        "properties": {
          "os": {
            "type": "string",
            "title": "Os"
          },
          "os_version": {
            "type": "string",
            "title": "Os Version"
          },
          "arch": {
            "type": "string",
            "title": "Arch"
          },
          "user": {
            "type": "string",
            "title": "User"
          },
          "home_dir": {
            "type": "string",
            "title": "Home Dir"
          },
          "workspace": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Workspace"
          },
          "timezone": {
            "type": "string",
            "title": "Timezone"
          },
          "occupied_ports": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "title": "Occupied Ports"
          }
        },
        "type": "object",
        "required": [
          "os",
          "os_version",
          "arch",
          "user",
          "home_dir",
          "timezone",
          "occupied_ports"
        ],
        "title": "SystemEnv"
      },
      "TextContent": {
        "properties": {
          "type": {
            "type": "string",
            "const": "text",
            "title": "Type"
          },
          "text": {
            "type": "string",
            "title": "Text"
          },
          "annotations": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/Annotations"
              },
              {
                "type": "null"
              }
            ]
          },
          "_meta": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Meta"
          }
        },
        "additionalProperties": true,
        "type": "object",
        "required": ["type", "text"],
        "title": "TextContent",
        "description": "Text content for a message."
      },
      "TextResourceContents": {
        "properties": {
          "uri": {
            "type": "string",
            "minLength": 1,
            "format": "uri",
            "title": "Uri"
          },
          "mimeType": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Mimetype"
          },
          "_meta": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Meta"
          },
          "text": {
            "type": "string",
            "title": "Text"
          }
        },
        "additionalProperties": true,
        "type": "object",
        "required": ["uri", "text"],
        "title": "TextResourceContents",
        "description": "Text contents of a resource."
      },
      "Tool": {
        "properties": {
          "name": {
            "type": "string",
            "title": "Name"
          },
          "title": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Title"
          },
          "description": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Description"
          },
          "inputSchema": {
            "additionalProperties": true,
            "type": "object",
            "title": "Inputschema"
          },
          "outputSchema": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Outputschema"
          },
          "icons": {
            "anyOf": [
              {
                "items": {
                  "$ref": "#/components/schemas/Icon"
                },
                "type": "array"
              },
              {
                "type": "null"
              }
            ],
            "title": "Icons"
          },
          "annotations": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ToolAnnotations"
              },
              {
                "type": "null"
              }
            ]
          },
          "_meta": {
            "anyOf": [
              {
                "additionalProperties": true,
                "type": "object"
              },
              {
                "type": "null"
              }
            ],
            "title": "Meta"
          },
          "execution": {
            "anyOf": [
              {
                "$ref": "#/components/schemas/ToolExecution"
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "additionalProperties": true,
        "type": "object",
        "required": ["name", "inputSchema"],
        "title": "Tool",
        "description": "Definition for a tool the client can call."
      },
      "ToolAnnotations": {
        "properties": {
          "title": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Title"
          },
          "readOnlyHint": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Readonlyhint"
          },
          "destructiveHint": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Destructivehint"
          },
          "idempotentHint": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Idempotenthint"
          },
          "openWorldHint": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Openworldhint"
          }
        },
        "additionalProperties": true,
        "type": "object",
        "title": "ToolAnnotations",
        "description": "Additional properties describing a Tool to clients.\n\nNOTE: all properties in ToolAnnotations are **hints**.\nThey are not guaranteed to provide a faithful description of\ntool behavior (including descriptive properties like `title`).\n\nClients should never make tool use decisions based on ToolAnnotations\nreceived from untrusted servers."
      },
      "ToolCategory": {
        "properties": {
          "category": {
            "type": "string",
            "title": "Category",
            "description": "Name of tool category"
          },
          "tools": {
            "items": {
              "$ref": "#/components/schemas/AvailableTool"
            },
            "type": "array",
            "title": "Tools",
            "description": "List of tools under this category"
          }
        },
        "type": "object",
        "required": ["category", "tools"],
        "title": "ToolCategory",
        "description": "Group available tools by capability"
      },
      "ToolExecution": {
        "properties": {
          "taskSupport": {
            "anyOf": [
              {
                "type": "string",
                "enum": ["forbidden", "optional", "required"]
              },
              {
                "type": "null"
              }
            ],
            "title": "Tasksupport"
          }
        },
        "additionalProperties": true,
        "type": "object",
        "title": "ToolExecution",
        "description": "Execution-related properties for a tool."
      },
      "ToolSpec": {
        "properties": {
          "ver": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Ver"
          },
          "bin": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Bin"
          },
          "alias": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "title": "Alias"
          }
        },
        "type": "object",
        "title": "ToolSpec",
        "description": "Tool specification"
      },
      "TypeTextRequest": {
        "properties": {
          "text": {
            "type": "string",
            "title": "Text"
          },
          "delay": {
            "type": "number",
            "title": "Delay",
            "default": 0
          }
        },
        "type": "object",
        "required": ["text"],
        "title": "TypeTextRequest"
      },
      "TypingAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "TYPING",
            "title": "Action Type",
            "default": "TYPING"
          },
          "text": {
            "type": "string",
            "minLength": 1,
            "title": "Text"
          },
          "use_clipboard": {
            "anyOf": [
              {
                "type": "boolean"
              },
              {
                "type": "null"
              }
            ],
            "title": "Use Clipboard",
            "description": "Use clipboard for better character support (recommended for special/ASCII characters)",
            "default": true
          }
        },
        "type": "object",
        "required": ["text"],
        "title": "TypingAction"
      },
      "UploadFileRequest": {
        "properties": {
          "selector": {
            "type": "string",
            "title": "Selector"
          },
          "files": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "title": "Files"
          }
        },
        "type": "object",
        "required": ["selector", "files"],
        "title": "UploadFileRequest"
      },
      "UtilConvertToMarkdownRequest": {
        "properties": {
          "uri": {
            "type": "string",
            "title": "Uri",
            "description": "The URI of the resource to convert"
          }
        },
        "type": "object",
        "required": ["uri"],
        "title": "UtilConvertToMarkdownRequest",
        "description": "convert to markdown request"
      },
      "ValidationError": {
        "properties": {
          "loc": {
            "items": {
              "anyOf": [
                {
                  "type": "string"
                },
                {
                  "type": "integer"
                }
              ]
            },
            "type": "array",
            "title": "Location"
          },
          "msg": {
            "type": "string",
            "title": "Message"
          },
          "type": {
            "type": "string",
            "title": "Error Type"
          }
        },
        "type": "object",
        "required": ["loc", "msg", "type"],
        "title": "ValidationError"
      },
      "WaitAction": {
        "properties": {
          "action_type": {
            "type": "string",
            "const": "WAIT",
            "title": "Action Type",
            "default": "WAIT"
          },
          "duration": {
            "type": "number",
            "exclusiveMinimum": 0,
            "title": "Duration",
            "description": "Duration to wait in seconds"
          }
        },
        "type": "object",
        "required": ["duration"],
        "title": "WaitAction"
      },
      "app__models__browser_sdk__WaitRequest": {
        "properties": {
          "type": {
            "type": "string",
            "enum": [
              "selector",
              "load",
              "url",
              "network_idle",
              "download",
              "function",
              "response",
              "request",
              "timeout"
            ],
            "title": "Type"
          },
          "selector": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Selector"
          },
          "state": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "State"
          },
          "url": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Url"
          },
          "save_path": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Save Path"
          },
          "timeout": {
            "type": "number",
            "title": "Timeout",
            "default": 30
          },
          "expression": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Expression"
          },
          "polling": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "null"
              }
            ],
            "title": "Polling"
          },
          "url_pattern": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ],
            "title": "Url Pattern"
          }
        },
        "type": "object",
        "required": ["type"],
        "title": "WaitRequest"
      },
      "app__schemas__file_watch__WaitRequest": {
        "properties": {
          "path": {
            "type": "string",
            "title": "Path",
            "description": "File path to wait for (exact match)"
          },
          "timeout": {
            "type": "integer",
            "maximum": 300,
            "minimum": 1,
            "title": "Timeout",
            "description": "Maximum wait time in seconds",
            "default": 30
          },
          "event_types": {
            "items": {
              "type": "string",
              "enum": ["create", "write", "remove", "rename", "chmod"]
            },
            "type": "array",
            "title": "Event Types",
            "description": "Event types to watch",
            "default": ["create", "write", "remove", "rename", "chmod"]
          }
        },
        "type": "object",
        "required": ["path"],
        "title": "FileWatchWaitRequest"
      }
    }
  }
}

---

--- METRICS ---
- Files Extracted: 45
- Estimated Token Budget: ~159779 tokens
- Canonical Reference: https://codewiki.google/github.com/agent-infra/sandbox