ਫ਼ੀਲਡਾਂ
{
"id": "draft-reply",
"label": "Draft the reply",
"intent": "Draft a reply to the customer message in _watch_payload using the reply-drafting skill.",
"skills": ["reply-drafting"],
"requires_tools": ["mail_message_send"],
"on_error": { "retry": 1, "fallback": "notify_owner" }
} | ਫ਼ੀਲਡ | ਡਿਫ਼ੌਲਟ | ਅਰਥ |
|---|---|---|
id | ਲਾਜ਼ਮੀ | ਵਰਕਫਲੋ ਅੰਦਰ ਵਿਲੱਖਣ। connections ਅਤੇ ਡਾਟਾ ਪਾਥਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। |
type | custom | ਇੱਕ ਕਰਮਚਾਰੀ ਕਦਮ, ਜਾਂ condition, loop, wait, http, command, decide ਵਿੱਚੋਂ ਇੱਕ। |
intent | ਕੋਈ ਨਹੀਂ | ਕਰਮਚਾਰੀ ਨੇ ਕੀ ਪੂਰਾ ਕਰਨਾ ਹੈ। ਕਰਮਚਾਰੀ ਕਦਮ ਨੂੰ intent ਜਾਂ steps ਚਾਹੀਦਾ ਹੈ। |
steps | [] | ਕ੍ਰਮਵਾਰ ਹਿਦਾਇਤਾਂ, ਜਦੋਂ ਇੱਕ ਵਾਕ ਕਾਫ਼ੀ ਨਾ ਹੋਵੇ। |
label | ਕੋਈ ਨਹੀਂ | ਮਾਲਕ ਨੂੰ ਦਿਸਣ ਵਾਲਾ ਨਾਮ। |
skills | [] | ਵਰਤਣ ਲਈ ਸਕਿੱਲ। ਇੱਥੇ ਦਰਜ ਮਾਰਕੀਟਪਲੇਸ ਸਕਿੱਲ ਕਰਮਚਾਰੀ ਦੇ ਨਾਲ ਇੰਸਟਾਲ ਹੁੰਦੇ ਹਨ। |
tools | [] | ਸੈੱਟ ਹੋਣ ’ਤੇ, ਸਿਰਫ਼ ਇਹੀ ਟੂਲ ਕਦਮ ਵਰਤ ਸਕਦਾ ਹੈ। |
requires_tools | [] | ਟੂਲ ਜਿਹਨਾਂ ਦਾ ਸਫ਼ਲ ਹੋਣਾ ਲਾਜ਼ਮੀ ਹੈ ਤਾਂ ਜੋ ਕਦਮ ਪੂਰਾ ਗਿਣਿਆ ਜਾਵੇ। |
cmds | [] | ਕਦਮ ਲਈ ਨਾਮ ਦਿੱਤੀਆਂ ਪਲੱਗਇਨ ਕਮਾਂਡਾਂ। |
mcps | [] | ਕਦਮ ਲਈ ਨਾਮ ਦਿੱਤੇ MCP ਸਰਵਰ। |
model | ਕੋਈ ਨਹੀਂ | ਇਸ ਕਦਮ ਲਈ ਮਾਡਲ id। |
params | ਕੋਈ ਨਹੀਂ | ਟਾਈਪ ਕੀਤੀਆਂ ਗਤੀਵਿਧੀਆਂ ਲਈ ਪੈਰਾਮੀਟਰ, ਅਤੇ ਕਰਮਚਾਰੀ ਕਦਮਾਂ ਲਈ maxIterations। |
min_iterations | ਕੋਈ ਨਹੀਂ | ਕਦਮ ਪੂਰਾ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਘੱਟੋ-ਘੱਟ ਮਾਡਲ ਵਾਰੀਆਂ। |
token_budget | ਕੋਈ ਨਹੀਂ | {max}। ਇੱਕ ਅੰਦਾਜ਼ਾ। |
on_error | {retry: 1, fallback: notify_owner} | ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ਾਂ, ਫਿਰ ਬਦਲਵਾਂ ਰਸਤਾ। ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ਾਂ ਤੋਂ ਬਾਅਦ ਕੋਈ ਵੀ ਨਾਕਾਮੀ ਰਨ ਖ਼ਤਮ ਕਰ ਦਿੰਦੀ ਹੈ। |
ਕਰਮਚਾਰੀ ਕਦਮ
ਕਰਮਚਾਰੀ ਕਦਮ ਕਰਮਚਾਰੀ ਦੀ ਇੱਕ ਵਾਰੀ ਵਜੋਂ ਚੱਲਦਾ ਹੈ: ਉਸ ਦੀ ਸ਼ਖ਼ਸੀਅਤ, ਮੈਮੋਰੀ ਅਤੇ ਕਨੈਕਸ਼ਨ ਲਾਗੂ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਇਹ 50 ਮਾਡਲ ਵਾਰੀਆਂ ਤੱਕ, ਜਾਂ params.maxIterations ਤੱਕ, ਵਰਤ ਸਕਦਾ ਹੈ। ਪਿਛਲੇ ਕਦਮਾਂ ਦੇ ਨਤੀਜੇ [Activity 'id' result] ਬਲਾਕਾਂ ਵਜੋਂ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ। ਜੋ ਕਦਮ emit ਸੂਚੀ ਨਾਲ ਵਰਕਫਲੋ ਖ਼ਤਮ ਕਰਦਾ ਹੈ, ਉਸ ਨੂੰ ਉਹਨਾਂ ਇਵੈਂਟਾਂ ਨਾਲ emit_event ਕਾਲ ਕਰਨ ਲਈ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਰਨ ਖ਼ਤਮ ਕਰਨ ਲਈ exit ਟੂਲ ਹਮੇਸ਼ਾ ਉਪਲਬਧ ਹੈ।
ਡਾਟਾ ਸੰਦਰਭ
ਟਾਈਪ ਕੀਤੀਆਂ ਗਤੀਵਿਧੀਆਂ ਇੱਕ ਆਬਜੈਕਟ ਤੋਂ ਬਿੰਦੂਦਾਰ ਪਾਥ ਰਾਹੀਂ ਮੁੱਲ ਪੜ੍ਹਦੀਆਂ ਹਨ: inputs ਵਿੱਚ ਰਨ ਦੇ ਇਨਪੁਟ ਹੁੰਦੇ ਹਨ, nodes.<id> ਵਿੱਚ ਹਰ ਪੂਰੀ ਹੋਈ ਗਤੀਵਿਧੀ ਦਾ ਆਉਟਪੁਟ (JSON ਹੋਵੇ ਤਾਂ JSON ਵਜੋਂ ਪਾਰਸ ਕੀਤਾ), ਅਤੇ item ਵਿੱਚ ਲੂਪ ਅੰਦਰ ਮੌਜੂਦਾ ਆਈਟਮ। ਸਾਦਾ ਪਾਥ ਪਹਿਲਾਂ inputs ਵਿੱਚ, ਫਿਰ nodes ਵਿੱਚ ਦੇਖਦਾ ਹੈ।
condition
{ "id": "large", "type": "condition", "params": { "expression": "inputs.amount >= 500" } } params.expression ਲਾਜ਼ਮੀ ਹੈ। ਇਸ ਦੇ ਬਾਹਰ ਜਾਣ ਵਾਲੇ ਕਨੈਕਸ਼ਨਾਂ ਦੇ ਲੇਬਲ True ਅਤੇ False ਹੁੰਦੇ ਹਨ। params.mode ਚੁਣਦਾ ਹੈ ਕਿ ਇਸ ਨੂੰ ਕਿਵੇਂ ਪੜ੍ਹਿਆ ਜਾਵੇ:
| ਮੋਡ | ਐਕਸਪ੍ਰੈਸ਼ਨ |
|---|---|
expression | ਡਿਫ਼ੌਲਟ। ==, !=, >=, <=, > ਜਾਂ < ਨਾਲ path op value, ਜਦੋਂ ਦੋਵੇਂ ਪਾਸੇ ਸੰਖਿਆਵਾਂ ਹੋਣ ਤਾਂ ਸੰਖਿਆਵਾਂ ਵਜੋਂ ਤੁਲਨਾ; ਜਾਂ ਸਾਦਾ ਪਾਥ, ਸੱਚ ਜਦੋਂ ਉਸ ਦਾ ਮੁੱਲ ਸੱਚ-ਵਰਗਾ ਹੋਵੇ। |
exists | ਇੱਕ ਪਾਥ; ਸੱਚ ਜਦੋਂ ਇਹ ਕਿਸੇ ਸੱਚ-ਵਰਗੇ ਮੁੱਲ ’ਤੇ ਪਹੁੰਚਦਾ ਹੈ। |
contains | path contains text, ਜਾਂ ਪਿਛਲੇ ਆਉਟਪੁਟ ਨਾਲ ਮੇਲੀ ਜਾਣ ਵਾਲੀ ਸਾਦੀ ਲਿਖਤ। |
regex | ਪਿਛਲੇ ਆਉਟਪੁਟ ਨਾਲ ਮੇਲਿਆ ਜਾਣ ਵਾਲਾ ਪੈਟਰਨ। |
loop
{ "id": "each-invoice", "type": "loop", "params": { "source": "nodes.fetch.invoices", "concurrency": 4 } } params.source ਇੱਕ ਸੂਚੀ ਦਾ ਪਾਥ ਹੈ। Each item ਲੇਬਲ ਵਾਲਾ ਕਨੈਕਸ਼ਨ ਬਾਡੀ ਵੱਲ ਜਾਂਦਾ ਹੈ, ਜੋ item ਸੈੱਟ ਕਰਕੇ ਹਰ ਆਈਟਮ ਲਈ ਇੱਕ ਵਾਰ ਚੱਲਦੀ ਹੈ; Done ਲੇਬਲ ਵਾਲਾ ਸਾਰੀਆਂ ਆਈਟਮਾਂ ਤੋਂ ਬਾਅਦ ਚੱਲਦਾ ਹੈ। ਦੁਹਰਾਅ ਇਕੱਠੇ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ concurrency ਸੈੱਟ ਨਾ ਕਰੋ। maxIterations ਅਤੇ batchSize ਵੀ ਮੰਨੇ ਜਾਂਦੇ ਹਨ।
"connections": [
{ "from": "__trigger__", "to": "fetch" },
{ "from": "fetch", "to": "each-invoice" },
{ "from": "each-invoice", "to": "check", "label": "Each item" },
{ "from": "each-invoice", "to": "report", "label": "Done" }
] wait, http ਅਤੇ command
{ "id": "pause", "type": "wait", "params": { "duration": "5m" } }
{ "id": "status", "type": "http", "params": { "url": "https://status.example.com/api", "method": "GET" } }
{ "id": "export", "type": "command", "params": { "command": "date -u" } } | ਕਿਸਮ | ਲਾਜ਼ਮੀ | ਵਿਹਾਰ |
|---|---|---|
wait | params.duration | s, m ਜਾਂ h ਵਿੱਚ ਦਿੱਤੀ ਮਿਆਦ ਲਈ ਰੁਕਦਾ ਹੈ। ਕਿਸੇ ਖ਼ਾਸ ਸਮੇਂ ਤੱਕ ਉਡੀਕ ਨਹੀਂ ਹੁੰਦੀ; ਕਿਸੇ ਇਵੈਂਟ ’ਤੇ ਮੁੜ ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਉਸ ’ਤੇ ਦੂਜਾ ਵਰਕਫਲੋ ਟ੍ਰਿਗਰ ਕਰੋ। |
http | params.url | ਬੇਨਤੀ ਭੇਜਦਾ ਹੈ। method, headers ਅਤੇ body ਵਿਕਲਪਿਕ ਹਨ। |
command | params.command | ਸ਼ੈੱਲ ਕਮਾਂਡ ਚਲਾਉਂਦਾ ਹੈ। ਇਸ ਦਾ stdout ਗਤੀਵਿਧੀ ਦਾ ਆਉਟਪੁਟ ਹੈ। |
decide
decide ਗਤੀਵਿਧੀ ਹੁਣ ਤੱਕ ਦੇ ਕੰਮ ਬਾਰੇ ਟਾਈਪ ਕੀਤੇ ਸਵਾਲ ਪੁੱਛਦੀ ਹੈ ਅਤੇ ਢਾਂਚਾਬੱਧ ਜਵਾਬ ਦਰਜ ਕਰਦੀ ਹੈ ਜਿਹਨਾਂ ’ਤੇ condition ਰੂਟ ਕਰ ਸਕਦੀ ਹੈ।
{
"id": "triage",
"type": "decide",
"params": {
"questions": {
"urgency": { "type": "score", "instructions": "How urgent is this request?", "criteria": ["low", "normal", "high"] },
"refund": { "type": "noul", "instructions": "The customer is asking for money back." }
},
"default": { "urgency": "normal", "refund": false }
}
} | ਸਵਾਲ ਦੀ ਕਿਸਮ | criteria | ਜਵਾਬ |
|---|---|---|
choice | ਵਿਕਲਪ ਤੋਂ ਵੇਰਵੇ ਦਾ ਆਬਜੈਕਟ, 2 ਤੋਂ 255 ਵਿਕਲਪ। | choice, confidence ਅਤੇ probabilities। |
score | 2 ਤੋਂ 10 ਕ੍ਰਮਵਾਰ ਪੱਧਰਾਂ ਦੀ ਸੂਚੀ। | 0 (ਪਹਿਲਾ ਪੱਧਰ) ਤੋਂ ਉੱਪਰ ਵੱਲ score, ਅਤੇ confidence। |
noul | ਕੋਈ ਨਹੀਂ। | noul, ਕਥਨ ਦੇ ਸੱਚ ਹੋਣ ਦੀ ਸੰਭਾਵਨਾ। |
ਕਿਸੇ ਜਵਾਬ ’ਤੇ condition ਨਾਲ ਰੂਟ ਕਰੋ, ਜਿਵੇਂ nodes.triage.urgency.score >= 1.5। ਜਦੋਂ ਕੋਈ ਫ਼ੈਸਲਾ ਨਾ ਹੋ ਸਕੇ ਤਾਂ params.default ਹਰ ਸਵਾਲ ਲਈ ਸੁਰੱਖਿਅਤ ਜਵਾਬ ਦਿੰਦਾ ਹੈ; ਡਿਫ਼ੌਲਟ ਜਵਾਬ ਦਾ confidence 0 ਹੁੰਦਾ ਹੈ। ਬਿਨਾਂ ਡਿਫ਼ੌਲਟ ਵਾਲੇ ਸਵਾਲ ਨੂੰ ਕੋਈ ਜਵਾਬ ਨਹੀਂ ਮਿਲਦਾ, ਇਸ ਲਈ ਉਸ ’ਤੇ ਬਣੀਆਂ conditions ਆਪਣਾ False ਕਿਨਾਰਾ ਲੈਂਦੀਆਂ ਹਨ।
ਗ਼ਲਤੀਆਂ
on_error.retry ਤੈਅ ਕਰਦਾ ਹੈ ਕਿ ਨਾਕਾਮ ਗਤੀਵਿਧੀ ਕਿੰਨੀ ਵਾਰ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾਵੇ; ਡਿਫ਼ੌਲਟ 1 ਹੈ। ਆਖ਼ਰੀ ਕੋਸ਼ਿਸ਼ ਤੋਂ ਬਾਅਦ ਰਨ ਖ਼ਤਮ ਹੋ ਜਾਂਦਾ ਹੈ, ਅਤੇ notify_owner ਦੇ ਡਿਫ਼ੌਲਟ fallback ਨਾਲ ਮਾਲਕ ਨੂੰ ਦੱਸਿਆ ਜਾਂਦਾ ਹੈ। ਰਨ ਸ਼ੁਰੂ ਹੋਣ ’ਤੇ Nebo ਹਰ ਟਾਈਪ ਕੀਤੀ ਗਤੀਵਿਧੀ ਦੇ ਲਾਜ਼ਮੀ ਪੈਰਾਮੀਟਰ ਜਾਂਚਦਾ ਹੈ, ਅਤੇ ਅਣਜਾਣ ਗਤੀਵਿਧੀ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਨ ਵਾਲੀ ਸ਼ਾਖ਼ਾ ਰੱਦ ਕਰਦਾ ਹੈ।