---
read_when:
    - आप स्पष्ट स्वीकृतियों वाले नियतात्मक बहु-चरणीय कार्यप्रवाह चाहते हैं
    - आपको पहले के चरणों को दोबारा चलाए बिना कार्यप्रवाह फिर से शुरू करना है
summary: फिर से शुरू किए जा सकने वाले अनुमोदन गेट्स के साथ OpenClaw के लिए टाइपयुक्त वर्कफ़्लो रनटाइम।
title: Lobster
x-i18n:
    generated_at: "2026-07-27T20:48:39Z"
    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 बहु-चरणीय टूल पाइपलाइनों को एक नियतात्मक टूल कॉल के रूप में चलाता है, जिसमें
स्पष्ट अनुमोदन चेकपॉइंट और फिर से शुरू करने के टोकन होते हैं। यह अलग किए गए बैकग्राउंड कार्य से
एक स्तर ऊपर स्थित है: कई अलग किए गए कार्यों में प्रवाहों को व्यवस्थित करने के लिए,
[Task Flow](/hi/automation/taskflow) (`openclaw tasks flow`) देखें; कार्य
गतिविधि लेजर के लिए, [बैकग्राउंड कार्य](/hi/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 बंडल किए गए
`@clawdbot/lobster` पैकेज को एम्बेडेड रनर के रूप में उपयोग करके 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":"..."}'
```

## केवल-JSON LLM चरण (llm-task)

किसी कार्यप्रवाह के भीतर **संरचित LLM चरण** के लिए, वैकल्पिक
`llm-task` Plugin टूल को सक्षम करें और उसे Lobster से कॉल करें:

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

### महत्वपूर्ण सीमा: एम्बेडेड Lobster बनाम `openclaw.invoke`

बंडल किया गया Lobster Plugin Gateway के भीतर कार्यप्रवाहों को **इन-प्रोसेस** चलाता है।
इस एम्बेडेड मोड में, नेस्ट किए गए OpenClaw CLI टूल कॉल के लिए `openclaw.invoke` को
Gateway URL/प्रमाणीकरण संदर्भ स्वचालित रूप से प्राप्त **नहीं** होता।

इसका अर्थ है कि यह पैटर्न **वर्तमान में एम्बेडेड रनर में विश्वसनीय नहीं है**:

```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
  }
}'
```

यदि आप आज एम्बेडेड Lobster Plugin का उपयोग कर रहे हैं, तो इनमें से किसी को प्राथमिकता दें:

- Lobster के बाहर सीधे `llm-task` टूल कॉल को, या
- समर्थित एम्बेडेड ब्रिज जोड़े जाने तक Lobster पाइपलाइन के भीतर गैर-`openclaw.invoke`
  चरणों को।

विवरण और कॉन्फ़िगरेशन विकल्पों के लिए [LLM कार्य](/hi/tools/llm-task) देखें।

## कार्यप्रवाह फ़ाइलें (.lobster)

Lobster `name`, `args`, `steps`, `env`,
`condition` और `approval` फ़ील्ड वाली YAML/JSON कार्यप्रवाह फ़ाइलें चला सकता है। टूल
कॉल में `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`            | Gateway cwd | सापेक्ष कार्यशील डायरेक्टरी; इसे Gateway की कार्यशील डायरेक्टरी के भीतर समाधान होना चाहिए (निरपेक्ष पथ अस्वीकार किए जाते हैं)। |
| `timeoutMs`      | `20000`     | सीमा पार होने पर रन को निरस्त करता है।                                                                                  |
| `maxStdoutBytes` | `512000`    | कैप्चर किया गया stdout या stderr इस आकार से अधिक होने पर रन को निरस्त करता है।                                               |
| `argsJson`       | -           | कार्यप्रवाह फ़ाइल के आर्ग्युमेंट की JSON स्ट्रिंग (इनलाइन पाइपलाइनों के लिए अनदेखी की जाती है)।                                      |

### `resume`

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

`resume` या तो `token` (`requiresApproval` से मिला पूरा फिर से शुरू करने का टोकन)
या `approvalId` (उसी ऑब्जेक्ट से मिली छोटी ID) स्वीकार करता है—रुके हुए
रन ने जो लौटाया हो उसका उपयोग करें। `approve` आवश्यक है।

### प्रबंधित Task Flow मोड

`run` पर `flowControllerId` और `flowGoal` (या `resume` पर `flowId` और
`flowExpectedRevision`) पास करने से कॉल साधारण एनवेलप लौटाने के बजाय Plugin
रनटाइम के प्रबंधित [Task Flow](/hi/automation/taskflow) API से संचालित होती है:
OpenClaw एक टिकाऊ प्रवाह रिकॉर्ड बनाता है या फिर से शुरू करता है, उस पर
Lobster एनवेलप लागू करता है (अनुमोदन पर `waiting`, पूर्ण होने पर `succeeded`/`failed`)
और `{ ok, envelope, flow, mutation }` लौटाता है। इस मोड के लिए
बाउंड Task Flow रनटाइम आवश्यक है और यह उस Plugin/कंट्रोलर कोड के लिए है जिसे
Gateway पुनरारंभों के बीच टिकाऊ प्रवाह स्थिति चाहिए, न कि सामान्य तदर्थ एजेंट उपयोग के लिए।

## आउटपुट एनवेलप

Lobster तीन में से किसी एक स्थिति वाला JSON एनवेलप लौटाता है:

- `ok`—सफलतापूर्वक पूरा हुआ
- `needs_approval`—रुका हुआ; `requiresApproval` में `resumeToken` और एक
  छोटी `approvalId` होती है, जिनमें से किसी से भी रन फिर से शुरू किया जा सकता है
- `cancelled`—स्पष्ट रूप से अस्वीकृत या रद्द किया गया

टूल एनवेलप को `content` (सुव्यवस्थित JSON) और `details`
(कच्चा ऑब्जेक्ट), दोनों में उपलब्ध कराता है।

## अनुमोदन

यदि `requiresApproval` मौजूद है, तो प्रॉम्प्ट की जाँच करें और निर्णय लें:

- `approve: true`—फिर से शुरू करें और दुष्प्रभावों को जारी रखें
- `approve: false`—कार्यप्रवाह को रद्द करके अंतिम रूप दें

कस्टम jq/heredoc संयोजन के बिना अनुमोदन अनुरोधों में JSON पूर्वावलोकन संलग्न करने के लिए
`approve --preview-from-stdin --limit N` का उपयोग करें। फिर से शुरू करने की स्थिति Lobster स्थिति डायरेक्टरी में
छोटी JSON फ़ाइलों के रूप में संग्रहीत होती है (डिफ़ॉल्ट रूप से `~/.lobster/state`,
`LOBSTER_STATE_DIR` से ओवरराइड करें); टोकन स्वयं केवल उस स्थिति का
पॉइंटर एन्कोड करता है, पूरी पाइपलाइन स्थिति नहीं।

## OpenProse

OpenProse, Lobster के साथ अच्छी तरह काम करता है: बहु-एजेंट
तैयारी को व्यवस्थित करने के लिए `/prose` का उपयोग करें, फिर नियतात्मक अनुमोदनों के लिए Lobster पाइपलाइन चलाएँ। यदि किसी Prose
प्रोग्राम को Lobster चाहिए, तो `tools.subagents.tools` के माध्यम से उप-एजेंटों के लिए
`lobster` टूल की अनुमति दें। [OpenProse](/hi/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 लॉग देखें। |

## अधिक जानें

- [Plugins](/hi/tools/plugin)
- [Plugin टूल लेखन](/hi/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)

## संबंधित

- [ऑटोमेशन](/hi/automation) - सभी ऑटोमेशन तंत्र
- [टूल्स का अवलोकन](/hi/tools) - सभी उपलब्ध एजेंट टूल्स