ಫೀಲ್ಡ್ಗಳು
{
"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, ಎರಡೂ ಬದಿಗಳು ಸಂಖ್ಯೆಗಳಾಗಿದ್ದಾಗ ಸಂಖ್ಯೆಗಳಾಗಿ ಹೋಲಿಸಲಾಗುತ್ತದೆ; ಅಥವಾ ಕೇವಲ ಪಾತ್, ಅದರ ಮೌಲ್ಯ truthy ಆಗಿದ್ದಾಗ true. |
exists | ಒಂದು ಪಾತ್; ಅದು truthy ಮೌಲ್ಯಕ್ಕೆ ಪರಿಹಾರವಾದಾಗ true. |
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 ನಲ್ಲಿನ ಅವಧಿಗೆ ವಿರಾಮ ನೀಡುತ್ತದೆ. wait-until ಇಲ್ಲ; ಈವೆಂಟ್ ಬಂದಾಗ ಮುಂದುವರಿಸಲು, ಅದರ ಮೇಲೆ ಎರಡನೇ ವರ್ಕ್ಫ್ಲೋವನ್ನು ಟ್ರಿಗರ್ ಮಾಡಿ. |
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. ಕೊನೆಯ ಮರುಪ್ರಯತ್ನದ ನಂತರ ರನ್ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ಡೀಫಾಲ್ಟ್ fallback ಆದ notify_owner ಇದ್ದರೆ ಮಾಲೀಕರಿಗೆ ತಿಳಿಸಲಾಗುತ್ತದೆ. ರನ್ ಪ್ರಾರಂಭವಾದಾಗ Nebo ಪ್ರತಿ ಟೈಪ್ ಮಾಡಿದ ಚಟುವಟಿಕೆಯ ಅಗತ್ಯ ಪ್ಯಾರಾಮೀಟರ್ಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಮತ್ತು ಅಜ್ಞಾತ ಚಟುವಟಿಕೆಗೆ ತೋರಿಸುವ ಶಾಖೆಯನ್ನು ತಿರಸ್ಕರಿಸುತ್ತದೆ.