---
read_when:
    - คุณต้องการเวิร์กโฟลว์หลายขั้นตอนที่ให้ผลลัพธ์แน่นอนและมีการอนุมัติอย่างชัดเจน
    - คุณต้องดำเนินเวิร์กโฟลว์ต่อโดยไม่เรียกใช้ขั้นตอนก่อนหน้านี้ซ้ำ
summary: รันไทม์เวิร์กโฟลว์แบบมีชนิดข้อมูลสำหรับ OpenClaw พร้อมจุดตรวจสอบการอนุมัติที่ดำเนินการต่อได้
title: Lobster
x-i18n:
    generated_at: "2026-07-19T07:35:43Z"
    model: gpt-5.6
    postprocess_version: locale-links-v1
    prompt_version: 32
    provider: openai
    source_hash: 85b7900f86bfedc9d73fcc91c3d0dac37b81f7413b1e68c54dd8a797b70f79fc
    source_path: tools/lobster.md
    workflow: 16
---

Lobster เรียกใช้ไปป์ไลน์เครื่องมือแบบหลายขั้นตอนเป็นการเรียกเครื่องมือเพียงครั้งเดียวที่ให้ผลลัพธ์แน่นอน พร้อม
จุดตรวจสอบการอนุมัติที่ชัดเจนและโทเค็นสำหรับดำเนินการต่อ โดยอยู่เหนือ
งานเบื้องหลังที่แยกออกไปอีกหนึ่งระดับ: สำหรับการประสานโฟลว์ระหว่างงานที่แยกออกไปหลายงาน
โปรดดู [โฟลว์งาน](/th/automation/taskflow) (`openclaw tasks flow`); สำหรับบัญชีกิจกรรมของงาน
โปรดดู [งานเบื้องหลัง](/th/automation/tasks)

## เหตุผล

หากไม่มี Lobster งานแบบหลายขั้นตอนจะต้องเรียกเครื่องมือไปกลับหลายครั้ง โดยให้
โมเดลประสานทุกขั้นตอน Lobster ย้ายการประสานนั้นไปไว้ในรันไทม์
ที่มีชนิดข้อมูลกำกับ:

- **เรียกครั้งเดียวแทนหลายครั้ง**: การเรียกเครื่องมือ Lobster ครั้งเดียวจะส่งคืนผลลัพธ์
  ที่มีโครงสร้างสำหรับทั้งไปป์ไลน์
- **มีการอนุมัติในตัว**: ผลข้างเคียง (ส่ง, โพสต์, ลบ) จะหยุดเวิร์กโฟลว์
  จนกว่าจะได้รับการอนุมัติอย่างชัดเจน
- **ดำเนินการต่อได้**: เวิร์กโฟลว์ที่หยุดจะส่งคืนโทเค็น; อนุมัติและดำเนินการต่อโดยไม่ต้อง
  เรียกใช้ขั้นตอนก่อนหน้าใหม่

Lobster เป็น DSL ขนาดเล็กที่มีขอบเขตจำกัด ไม่ใช่ภาษาเขียนสคริปต์ทั่วไป:
การอนุมัติ/ดำเนินการต่อเป็นองค์ประกอบพื้นฐานที่คงทนและมีอยู่ในตัว; ไปป์ไลน์อยู่ในรูปข้อมูล (จึง
บันทึกล็อก, เปรียบเทียบความแตกต่าง, เล่นซ้ำ และตรวจทานได้ง่าย); ไวยากรณ์ขนาดเล็กจำกัดเส้นทางโค้ดที่ "สร้างสรรค์" เพื่อให้
การตรวจสอบความถูกต้องยังคงสอดคล้องกับความเป็นจริง; การหมดเวลา, ขีดจำกัดเอาต์พุต, การตรวจสอบแซนด์บ็อกซ์ และ
รายการที่อนุญาตถูกบังคับใช้โดยรันไทม์ ไม่ใช่โดยแต่ละสคริปต์ แต่ละขั้นตอนยังคง
เรียก CLI หรือสคริปต์ใดก็ได้—หากต้องการภาษาเขียนที่มีความสามารถมากขึ้น ให้สร้างไฟล์ `.lobster` จากเครื่องมืออื่น

หากไม่มี Lobster การคัดแยกอีเมลเป็นประจำจะมีลักษณะดังนี้:

```text
ผู้ใช้: "ตรวจสอบอีเมลของฉันและร่างข้อความตอบกลับ"
→ openclaw เรียก gmail.list
→ LLM สรุป
→ ผู้ใช้: "ร่างข้อความตอบกลับสำหรับ #2 และ #5"
→ LLM ร่างข้อความ
→ ผู้ใช้: "ส่ง #2"
→ openclaw เรียก gmail.send
(ทำซ้ำทุกวัน โดยไม่มีหน่วยความจำว่าได้คัดแยกอะไรไปแล้ว)
```

เมื่อใช้ Lobster งานเดียวกันจะเป็นการเรียกครั้งเดียวที่หยุดเพื่อรอการอนุมัติและดำเนินการต่อได้:

```json
{ "action": "run", "pipeline": "email.triage --limit 20", "timeoutMs": 30000 }
```

```json
{
  "ok": true,
  "status": "needs_approval",
  "output": [{ "summary": "ต้องตอบกลับ 5 รายการ และต้องดำเนินการ 2 รายการ" }],
  "requiresApproval": {
    "type": "approval_request",
    "prompt": "ส่งข้อความตอบกลับฉบับร่าง 2 รายการหรือไม่?",
    "items": [],
    "resumeToken": "..."
  }
}
```

## วิธีการทำงาน

OpenClaw เรียกใช้เวิร์กโฟลว์ Lobster **ภายในโพรเซส** โดยใช้แพ็กเกจ
`@clawdbot/lobster` ที่รวมมาให้เป็นตัวเรียกใช้แบบฝัง ไม่มีการสร้างโพรเซสย่อย
`lobster` ภายนอก; การเรียกเครื่องมือจะส่งคืนเอนเวโลป JSON โดยตรง หาก
ไปป์ไลน์หยุดเพื่อรอการอนุมัติ เอนเวโลปจะมีโทเค็นสำหรับดำเนินการต่อ (หรือ ID
การอนุมัติแบบสั้น) เพื่อให้ดำเนินการต่อภายหลังได้

## การเปิดใช้งาน

Lobster เป็นเครื่องมือ Plugin **เสริม** ซึ่งไม่ได้เปิดใช้งานโดยค่าเริ่มต้น โดยรวมมาให้
แล้ว จึงไม่ต้องติดตั้งแยก—เพียงอนุญาตเครื่องมือ:

```json
{
  "tools": {
    "alsoAllow": ["lobster"]
  }
}
```

หรือตั้งค่าแยกตามเอเจนต์:

```json
{
  "agents": {
    "list": [
      {
        "id": "main",
        "tools": {
          "alsoAllow": ["lobster"]
        }
      }
    ]
  }
}
```

<Note>
`alsoAllow` เพิ่ม `lobster` บนโปรไฟล์เครื่องมือที่ใช้งานอยู่โดยไม่
จำกัดเครื่องมือหลักอื่นๆ ใช้ `tools.allow` เฉพาะเมื่อต้องการใช้โหมด
รายการที่อนุญาตแบบจำกัดเท่านั้น
</Note>

เครื่องมือนี้จะถูกปิดใช้งานทั้งหมดในบริบทเครื่องมือแบบแซนด์บ็อกซ์

หากต้องการ Lobster CLI แบบสแตนด์อโลนสำหรับการพัฒนาหรือไปป์ไลน์ภายนอก
(นอกตัวเรียกใช้ Gateway แบบฝัง) ให้ติดตั้งจาก
[ที่เก็บ Lobster](https://github.com/openclaw/lobster) และเพิ่ม `lobster` ลงใน
`PATH`

## รูปแบบ: CLI ขนาดเล็ก + ไปป์ JSON + การอนุมัติ

สร้างคำสั่งขนาดเล็กที่สื่อสารด้วย JSON แล้วเชื่อมคำสั่งเหล่านั้นเป็นการเรียก Lobster ครั้งเดียว
(ชื่อคำสั่งด้านล่างเป็นเพียงตัวอย่าง—ให้แทนที่ด้วยชื่อของคุณเอง)

```bash
inbox list --json
inbox categorize --json
inbox apply --json
```

```json
{
  "action": "run",
  "pipeline": "exec --json --shell 'inbox list --json' | exec --stdin json --shell 'inbox categorize --json' | exec --stdin json --shell 'inbox apply --json' | approve --preview-from-stdin --limit 5 --prompt 'นำการเปลี่ยนแปลงไปใช้หรือไม่?'",
  "timeoutMs": 30000
}
```

หากไปป์ไลน์ร้องขอการอนุมัติ ให้ดำเนินการต่อด้วยโทเค็น:

```json
{
  "action": "resume",
  "token": "<resumeToken>",
  "approve": true
}
```

ตัวอย่าง: แมปรายการอินพุตไปยังการเรียกเครื่องมือ:

```bash
gog.gmail.search --query 'newer_than:1d' \
  | openclaw.invoke --tool message --action send --each --item-key message --args-json '{"provider":"telegram","to":"..."}'
```

## ขั้นตอน LLM ที่ใช้เฉพาะ JSON (llm-task)

สำหรับ **ขั้นตอน LLM แบบมีโครงสร้าง** ภายในเวิร์กโฟลว์ ให้เปิดใช้
เครื่องมือ Plugin `llm-task` เสริมและเรียกจาก Lobster:

```json
{
  "plugins": {
    "entries": {
      "llm-task": { "enabled": true }
    }
  },
  "agents": {
    "list": [
      {
        "id": "main",
        "tools": { "alsoAllow": ["llm-task"] }
      }
    ]
  }
}
```

### ข้อจำกัดสำคัญ: Lobster แบบฝังเทียบกับ `openclaw.invoke`

Plugin Lobster ที่รวมมาให้จะเรียกใช้เวิร์กโฟลว์ **ภายในโพรเซส** ภายใน Gateway
ในโหมดฝังนี้ `openclaw.invoke` จะ **ไม่** รับช่วงบริบท URL/การยืนยันตัวตนของ
Gateway โดยอัตโนมัติสำหรับการเรียกเครื่องมือ OpenClaw CLI ที่ซ้อนอยู่

ซึ่งหมายความว่ารูปแบบนี้ **ยังไม่เสถียรในตัวเรียกใช้แบบฝังในขณะนี้**:

```lobster
openclaw.invoke --tool llm-task --action json --args-json '{ ... }'
```

ใช้ตัวอย่างด้านล่างเฉพาะเมื่อเรียกใช้ **Lobster CLI แบบสแตนด์อโลน** ใน
สภาพแวดล้อมที่กำหนดค่า `openclaw.invoke` ด้วยบริบท Gateway/การยืนยันตัวตนที่ถูกต้อง
ไว้แล้ว

```lobster
openclaw.invoke --tool llm-task --action json --args-json '{
  "prompt": "จากอีเมลอินพุต ให้ส่งคืนเจตนาและข้อความร่าง",
  "thinking": "low",
  "input": { "subject": "สวัสดี", "body": "ช่วยฉันได้ไหม?" },
  "schema": {
    "type": "object",
    "properties": {
      "intent": { "type": "string" },
      "draft": { "type": "string" }
    },
    "required": ["intent", "draft"],
    "additionalProperties": false
  }
}'
```

หากกำลังใช้ Plugin Lobster แบบฝังในปัจจุบัน ให้เลือกใช้:

- การเรียกเครื่องมือ `llm-task` โดยตรงนอก Lobster หรือ
- ขั้นตอนที่ไม่ใช่ `openclaw.invoke` ภายในไปป์ไลน์ Lobster จนกว่าจะเพิ่มบริดจ์แบบฝัง
  ที่รองรับ

โปรดดูรายละเอียดและตัวเลือกการกำหนดค่าที่ [งาน LLM](/th/tools/llm-task)

## ไฟล์เวิร์กโฟลว์ (.lobster)

Lobster สามารถเรียกใช้ไฟล์เวิร์กโฟลว์ YAML/JSON ที่มีฟิลด์ `name`, `args`, `steps`, `env`,
`condition` และ `approval` ได้ ตั้งค่า `pipeline` เป็นพาธไฟล์ในการเรียก
เครื่องมือ

```yaml
name: inbox-triage
args:
  tag:
    default: "family"
steps:
  - id: collect
    command: inbox list --json
  - id: categorize
    command: inbox categorize --json
    stdin: $collect.stdout
  - id: approve
    command: inbox apply --approve
    stdin: $categorize.stdout
    approval: required
  - id: execute
    command: inbox apply --execute
    stdin: $categorize.stdout
    condition: $approve.approved
```

หมายเหตุ:

- `stdin: $step.stdout` และ `stdin: $step.json` ส่งเอาต์พุตของขั้นตอนก่อนหน้า
- `condition` (หรือ `when`) สามารถควบคุมการเรียกใช้ขั้นตอนตาม `$step.approved`

### ตัวแปรสภาพแวดล้อมที่แทรกเข้ามา

เชลล์ของทุกขั้นตอนจะรับช่วงสภาพแวดล้อมหลัก รวมถึงตัวแปรที่ Lobster แทรกเข้ามา
ต่อไปนี้ เพื่อให้คำสั่งอ้างอิงอาร์กิวเมนต์เวิร์กโฟลว์ที่ประมวลผลแล้วได้โดยไม่ต้องฝัง
ค่าดิบลงในสตริงคำสั่ง:

- `LOBSTER_ARG_<NAME>` — หนึ่งตัวต่ออาร์กิวเมนต์เวิร์กโฟลว์ ชื่อจะถูกแปลงเป็นตัวพิมพ์ใหญ่ โดยแต่ละ
  ชุดของอักขระที่ไม่ใช่ตัวอักษรหรือตัวเลขจะถูกรวมเป็น `_` ดังนั้นอาร์กิวเมนต์ `user-id` จะกลายเป็น
  `LOBSTER_ARG_USER_ID`
- `LOBSTER_ARGS_JSON` — อาร์กิวเมนต์ที่ประมวลผลแล้วทั้งหมดในรูปสตริง JSON เดียว

นี่คือชุดตัวแปรที่แทรกเข้ามาทั้งหมด **ไม่มี** ตัวแปรเอาต์พุตแยกตามขั้นตอน
เช่น `LOBSTER_STEP_<id>_STDOUT` หรือ `LOBSTER_STEP_<id>_JSON_<field>`; เชลล์จะ
ถือว่าชื่อเหล่านั้นไม่ได้ตั้งค่าไว้ ดังนั้นค่าเริ่มต้นจากการขยายพารามิเตอร์อาจซ่อนข้อผิดพลาดได้
ให้อ่านเอาต์พุตของขั้นตอนก่อนหน้าผ่านการอ้างอิงขั้นตอนแทน—`$step.stdout`,
`$step.json` หรือ `$step.json.<field>`—ในค่า `stdin:`, `env:` หรือ `condition:`
(`LOBSTER_STATE_DIR` เป็นการตั้งค่ารันไทม์แยกต่างหากสำหรับไดเรกทอรีสถานะ
ไม่ใช่อาร์กิวเมนต์ต่อการเรียกใช้)

## พารามิเตอร์เครื่องมือ

### `run`

```json
{
  "action": "run",
  "pipeline": "gog.gmail.search --query 'newer_than:1d' | email.triage",
  "cwd": "workspace",
  "timeoutMs": 30000,
  "maxStdoutBytes": 512000
}
```

เรียกใช้ไฟล์เวิร์กโฟลว์พร้อมอาร์กิวเมนต์:

```json
{
  "action": "run",
  "pipeline": "/path/to/inbox-triage.lobster",
  "argsJson": "{\"tag\":\"family\"}"
}
```

| ฟิลด์            | ค่าเริ่มต้น     | หมายเหตุ                                                                                                        |
| ---------------- | ----------- | ------------------------------------------------------------------------------------------------------------ |
| `pipeline`       | จำเป็น    | สตริงไปป์ไลน์แบบอินไลน์ หรือพาธที่ลงท้ายด้วย `.lobster`/`.yaml`/`.yml`/`.json` สำหรับไฟล์เวิร์กโฟลว์           |
| `cwd`            | cwd ของ Gateway | ไดเรกทอรีทำงานแบบสัมพัทธ์; ต้องประมวลผลเป็นพาธภายในไดเรกทอรีทำงานของ Gateway (ระบบจะปฏิเสธพาธแบบสัมบูรณ์) |
| `timeoutMs`      | `20000`     | ยกเลิกการเรียกใช้หากเกินค่านี้                                                                                  |
| `maxStdoutBytes` | `512000`    | ยกเลิกการเรียกใช้หาก stdout หรือ stderr ที่บันทึกไว้มีขนาดเกินค่านี้                                               |
| `argsJson`       | -           | สตริง JSON ของอาร์กิวเมนต์สำหรับไฟล์เวิร์กโฟลว์ (จะถูกละเว้นสำหรับไปป์ไลน์แบบอินไลน์)                                      |

### `resume`

```json
{
  "action": "resume",
  "token": "<resumeToken>",
  "approve": true
}
```

`resume` ยอมรับได้ทั้ง `token` (โทเค็นสำหรับดำเนินการต่อแบบเต็มจาก `requiresApproval`)
หรือ `approvalId` (ID แบบสั้นจากออบเจ็กต์เดียวกัน)—ให้ใช้ค่าที่การเรียกใช้ซึ่งหยุดไว้
ส่งคืนมา ต้องระบุ `approve`

### โหมดโฟลว์งานที่มีการจัดการ

การส่ง `flowControllerId` และ `flowGoal` ใน `run` (หรือ `flowId` และ
`flowExpectedRevision` ใน `resume`) จะส่งการเรียกผ่าน API
[โฟลว์งาน](/th/automation/taskflow) ที่มีการจัดการของรันไทม์ Plugin แทนการส่งคืน
เอนเวโลปเปล่า: OpenClaw จะสร้างหรือดำเนินการต่อระเบียนโฟลว์แบบคงทน นำ
เอนเวโลป Lobster ไปใช้กับระเบียนนั้น (`waiting` เมื่ออนุมัติ, `succeeded`/`failed` เมื่อ
เสร็จสมบูรณ์) และส่งคืน `{ ok, envelope, flow, mutation }` โหมดนี้ต้องมี
รันไทม์โฟลว์งานที่ผูกไว้ และมีไว้สำหรับโค้ด Plugin/ตัวควบคุมที่ต้องการ
สถานะโฟลว์แบบคงทนข้ามการรีสตาร์ต Gateway ไม่ใช่สำหรับการใช้งานเฉพาะกิจทั่วไปของเอเจนต์

## เอนเวโลปเอาต์พุต

Lobster ส่งคืนเอนเวโลป JSON ที่มีหนึ่งในสามสถานะ:

- `ok` — เสร็จสมบูรณ์สำเร็จ
- `needs_approval` — หยุดชั่วคราว; `requiresApproval` มี `resumeToken` และ
  `approvalId` แบบสั้น ซึ่งใช้ค่าใดค่าหนึ่งเพื่อดำเนินการต่อได้
- `cancelled` — ถูกปฏิเสธหรือยกเลิกอย่างชัดเจน

เครื่องมือจะแสดงเอนเวโลปทั้งใน `content` (JSON ที่จัดรูปแบบให้อ่านง่าย) และ `details`
(ออบเจ็กต์ดิบ)

## การอนุมัติ

หากมี `requiresApproval` ให้ตรวจสอบข้อความแจ้งและตัดสินใจ:

- `approve: true` — ดำเนินการต่อและทำผลข้างเคียงต่อไป
- `approve: false` — ยกเลิกและทำให้เวิร์กโฟลว์สิ้นสุด

ใช้ `approve --preview-from-stdin --limit N` เพื่อแนบตัวอย่าง JSON กับ
คำขออนุมัติโดยไม่ต้องใช้ jq/heredoc แบบกำหนดเอง สถานะสำหรับดำเนินการต่อจะถูกจัดเก็บเป็น
ไฟล์ JSON ขนาดเล็กภายใต้ไดเรกทอรีสถานะ Lobster (ค่าเริ่มต้นคือ `~/.lobster/state`
และเขียนทับได้ด้วย `LOBSTER_STATE_DIR`); ตัวโทเค็นจะเข้ารหัสเพียง
ตัวชี้ไปยังสถานะนั้น ไม่ใช่สถานะทั้งหมดของไปป์ไลน์

## OpenProse

OpenProse ทำงานร่วมกับ Lobster ได้ดี: ใช้ `/prose` เพื่อประสานการเตรียมงาน
แบบหลายเอเจนต์ จากนั้นเรียกใช้ไปป์ไลน์ Lobster เพื่อการอนุมัติที่ให้ผลลัพธ์แน่นอน หากโปรแกรม Prose
ต้องใช้ Lobster ให้อนุญาตเครื่องมือ `lobster` สำหรับเอเจนต์ย่อยผ่าน
`tools.subagents.tools` โปรดดู [OpenProse](/th/prose)

## ความปลอดภัย

- **เฉพาะภายในโปรเซสบนเครื่องเท่านั้น** - เวิร์กโฟลว์ทำงานภายในโปรเซส Gateway โดยไม่มี
  การเรียกผ่านเครือข่ายจากตัว Plugin เอง
- **ไม่มีข้อมูลลับ** - Lobster ไม่ได้จัดการ OAuth แต่จะเรียกใช้เครื่องมือ OpenClaw ที่
  จัดการเรื่องนี้
- **รองรับแซนด์บ็อกซ์** - ปิดใช้งานเมื่อบริบทของเครื่องมืออยู่ในแซนด์บ็อกซ์
- **เสริมความปลอดภัย** - ตัวรันเนอร์แบบฝังตัวบังคับใช้การหมดเวลาและขีดจำกัดเอาต์พุต

## การแก้ไขปัญหา

| ข้อผิดพลาด                                                   | สาเหตุ / วิธีแก้ไข                                                                |
| ------------------------------------------------------------- | -------------------------------------------------------------------------------- |
| `lobster runtime timed out`                                           | ไปป์ไลน์ใช้เวลาเกิน `timeoutMs` ให้เพิ่มค่านี้หรือแบ่งไปป์ไลน์                   |
| `lobster stdout exceeded maxStdoutBytes` (หรือ `stderr`)                 | เอาต์พุตที่บันทึกไว้เกินขีดจำกัด ให้เพิ่ม `maxStdoutBytes` หรือลดเอาต์พุต             |
| `run --args-json must be valid JSON`                                           | แยกวิเคราะห์ `argsJson` (การเรียกใช้ไฟล์เวิร์กโฟลว์) ไม่สำเร็จ ให้แก้ไขสตริง JSON |
| `lobster runtime failed` (หรือข้อความ `runtime_error` อื่น)     | รันไทม์แบบฝังตัวส่งคืนเอนเวโลปข้อผิดพลาด ตรวจสอบบันทึก Gateway เพื่อดูรายละเอียด         |

## เรียนรู้เพิ่มเติม

- [Plugin](/th/tools/plugin)
- [การสร้างเครื่องมือ Plugin](/th/plugins/building-plugins#registering-agent-tools)

## กรณีศึกษา: เวิร์กโฟลว์จากชุมชน

ตัวอย่างสาธารณะหนึ่งรายการคือ CLI "สมองที่สอง" + ไปป์ไลน์ Lobster ซึ่งจัดการคลัง
Markdown สามคลัง (ส่วนตัว, คู่ชีวิต, ใช้ร่วมกัน) CLI ส่งออก JSON สำหรับสถิติ
รายการกล่องขาเข้า และการสแกนข้อมูลที่ล้าสมัย โดย Lobster เชื่อมคำสั่งเหล่านั้นเป็นเวิร์กโฟลว์
เช่น `weekly-review`, `inbox-triage`, `memory-consolidation` และ
`shared-task-sync` ซึ่งแต่ละรายการมีจุดตรวจสอบการอนุมัติ AI จะทำหน้าที่ตัดสินใจ
(การจัดหมวดหมู่) เมื่อพร้อมใช้งาน และจะเปลี่ยนไปใช้กฎแบบกำหนดแน่นอนเมื่อ
ไม่พร้อมใช้งาน

- เธรด: [https://x.com/plattenschieber/status/2014508656335770033](https://x.com/plattenschieber/status/2014508656335770033)
- ที่เก็บโค้ด: [https://github.com/bloomedai/brain-cli](https://github.com/bloomedai/brain-cli)

## ที่เกี่ยวข้อง

- [ระบบอัตโนมัติ](/th/automation) - กลไกการทำงานอัตโนมัติทั้งหมด
- [ภาพรวมเครื่องมือ](/th/tools) - เครื่องมือเอเจนต์ที่พร้อมใช้งานทั้งหมด
