ఫీల్డ్లు
{
"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, వాక్యం నిజమయ్యే సంభావ్యత. |
nodes.triage.urgency.score >= 1.5 వంటి conditionతో జవాబుపై రూట్ చేయండి. ఏ నిర్ణయం తీసుకోలేనప్పుడు ప్రతి ప్రశ్నకు సురక్షితమైన జవాబును params.default ఇస్తుంది; డిఫాల్ట్ జవాబుకు confidence 0. డిఫాల్ట్ లేని ప్రశ్నకు జవాబు ఉండదు, కాబట్టి దానిపై ఉన్న conditionలు తమ False అంచును తీసుకుంటాయి.
ఎర్రర్లు
విఫలమైన కార్యకలాపాన్ని ఎన్నిసార్లు మళ్లీ ప్రయత్నించాలో on_error.retry సెట్ చేస్తుంది; డిఫాల్ట్ 1. చివరి ప్రయత్నం తర్వాత రన్ ముగుస్తుంది, డిఫాల్ట్ fallback అయిన notify_ownerతో యజమానికి తెలియజేయబడుతుంది. రన్ ప్రారంభమైనప్పుడు Nebo ప్రతి టైప్డ్ కార్యకలాపం తప్పనిసరి పారామీటర్లను తనిఖీ చేస్తుంది, తెలియని కార్యకలాపాన్ని సూచించే శాఖను తిరస్కరిస్తుంది.