ခြုံငုံသုံးသပ်ချက်
Nebo ဆိုသည်မှာ
Nebo သည် ကိုယ်ပိုင် ဒက်စ်တော့ပ် AI လက်ထောက် ဖြစ်သည် — သင့်ဒစ်ဂျစ်တယ်ဘဝကို စီမံပေးသော အမြဲလည်ပတ်နေသည့် AI ဝန်ထမ်း။ Nebo ကို စမတ်ဖုန်းကဲ့သို့ စဉ်းစားကြည့်ပါ- ၎င်း၏ အက်ပ်များမှတစ်ဆင့် အပြောင်းအလဲကြီး ဖြစ်စေသော အစွမ်းထက်သည့် ပလက်ဖောင်း။
Nebo သည် သူ့ဘာသာသူပင် မှတ်ဉာဏ်၊ အချိန်ဇယားဆွဲခြင်း၊ ဝဘ်ကြည့်ရှုခြင်း၊ ဖိုင်စီမံခြင်းနှင့် shell ဝင်ရောက်ခွင့်တို့ ပါဝင်သော စွမ်းရည်ရှိ AI ဝန်ထမ်း ဖြစ်သည်။ သို့သော် တကယ့်သော့ချက်မှာ အက်ပ်များ ဖြစ်ပါသည်။ စမတ်ဖုန်း၏ စွမ်းအားသည် ၎င်း၏ အက်ပ်ဂေဟစနစ်မှ လာသကဲ့သို့ Nebo ၏ စွမ်းအားသည်လည်း ၎င်းလုပ်နိုင်သည့်အရာများကို တိုးချဲ့ပေးသော အက်ပ်များမှ လာပါသည်။
အက်ပ်များ ဆိုသည်မှာ
Nebo အက်ပ်များသည် ကိုယ်ပိုင်ပြီးပြည့်စုံပြီး ကြိုတင် compile လုပ်ထားသော အံ့ဖွယ်လုပ်ဆောင်ချက် ယူနစ်များ ဖြစ်သည်။ အက်ပ်တစ်ခုစီသည် Nebo ကို စွမ်းအားထူးအသစ်တစ်ခု ပေးပါသည် — ပြက္ခဒိန် စီမံခြင်း၊ အီးမေးလ် ခွဲခြားခြင်း၊ ပရောဂျက် ခြေရာခံခြင်း၊ အိမ် အလိုအလျောက်စနစ်၊ ငွေကြေး ခွဲခြမ်းစိတ်ဖြာခြင်း — ဆော့ဖ်ဝဲရေးသားသူ စိတ်ကူးနိုင်သမျှ အရာအားလုံး။
အက်ပ်များသည် အလွန်လုံခြုံသော နည်းလမ်းဖြင့် အံ့ဖွယ်စွမ်းအားကို ပေးပါသည်။ အက်ပ်တိုင်းသည် ပုံသေအားဖြင့် ငြင်းပယ်ထားသော ခွင့်ပြုချက်များဖြင့် sandbox ထဲတွင် လည်ပတ်ပါသည်။ ၎င်း၏ manifest တွင် ကြေညာထားပြီး အသုံးပြုသူ အတည်ပြုထားသည့်အရာကိုသာ ဝင်ရောက်နိုင်ပါသည်။
အင်တာဖေ့စ်သည် 100% စကားပြောဆိုမှုဖြင့် ဖြစ်သည်။ အသုံးပြုသူများသည် သီးခြား မျက်နှာပြင်များ သို့မဟုတ် ဒက်ရှ်ဘုတ်များမှတစ်ဆင့် အက်ပ်များနှင့် မဆက်ဆံပါ။ ၎င်းတို့က Nebo နှင့် စကားပြောပြီး Nebo က အလုပ်ပြီးမြောက်ရန် အက်ပ်၏ ကိရိယာများကို အသုံးပြုပါသည်။ "မနက်ဖြန် ငါ့ပြက္ခဒိန်မှာ ဘာရှိလဲ" — Nebo က ပြက္ခဒိန်အက်ပ်ကို ခေါ်သည်။ "Sarah နဲ့ ညနေ 3 နာရီမှာ အစည်းအဝေး တစ်ခု ဖန်တီးပေး" — Nebo က ပြက္ခဒိန်အက်ပ်ကို ခေါ်သည်။ အသုံးပြုသူသည် စကားပြောဆိုမှုမှ ဘယ်တော့မှ ထွက်ခွာရန် မလိုပါ။
အက်ပ်များသည် ရွေးချယ်နိုင်သော ဆက်တင် UI ကို ပေးနိုင်ပါသည် — Nebo ၏ built-in browser ဝင်းဒိုးတွင် ပွင့်လာသော ဖွဲ့စည်းမှု panel ဖြစ်သည်။ ဤနေရာတွင် အသုံးပြုသူများက API key များ ထည့်ခြင်း၊ လုပ်ဆောင်ချက်များ ဖွင့်ပိတ်ခြင်းနှင့် အက်ပ်ကို ဖွဲ့စည်းခြင်း ပြုလုပ်ပါသည်။ ဆက်တင် UI ကို manifest ရှိ settings array က မောင်းနှင်ပါသည် (Nebo က ဖောင်ကို အလိုအလျောက် ပြသပေးသည်)၊ သို့မဟုတ် အက်ပ်က ui စွမ်းရည်မှတစ်ဆင့် ၎င်း၏ ကိုယ်ပိုင် စိတ်ကြိုက် UI အပြည့်အစုံကို ပေးနိုင်ပါသည်။
အက်ပ်များသည် Nebo ၏ built-in စွမ်းရည်များကို အစားထိုးပြီး တိုးချဲ့ပေးပါသည်။ Nebo တွင် အခြေခံ ပလက်ဖောင်း ကိရိယာများ (စက်တွင်း ပြက္ခဒိန် ဝင်ရောက်ခွင့်၊ screenshot များ စသည်) ပါဝင်လာပါသည်။ ပြက္ခဒိန်အက်ပ်ကို ထည့်သွင်းသည့်အခါ ၎င်းသည် built-in ပြက္ခဒိန် ကိရိယာကို အစားထိုးပြီး superset တစ်ခု ဖြစ်လာပါသည် — စက်တွင်း + cloud + စုစည်းခြင်း + အချိန်လွတ် စစ်ဆေးခြင်း။
Compile လုပ်ထားသည်သာ မူဝါဒ
Nebo သည် compile လုပ်ထားသော binary သာ ခွင့်ပြုသည့် တင်းကျပ်သော မူဝါဒကို ကျင့်သုံးပါသည်။ အက်ပ်အားလုံးသည် native compile လုပ်ထားသော executable များ ဖြစ်ရပါမည်။
| အခြေအနေ | ဘာသာစကားများ |
|---|---|
| ပံ့ပိုးထားသည် | Go (အကြံပြုသည်)၊ Rust၊ C/C++၊ Zig |
| ငြင်းပယ်ထားသည် | Python၊ Node.js၊ Ruby၊ Java၊ .NET၊ shell script များ |
အကြောင်းရင်း-
- AI ကိုယ်တိုင်ပြင်ဆင်ခြင်းကို ကာကွယ်ခြင်း — shell ဝင်ရောက်ခွင့်ရှိသော AI ဝန်ထမ်းသည် interpret လုပ်သော script ၏ အပြုအမူကို runtime တွင် ပြင်ဆင်နိုင်ပါသည်။ Compile လုပ်ထားသော binary များသည် လက်မှတ်ထိုးပြီးနောက် ပြောင်းလဲ၍ မရပါ။
- လက်မှတ် ခိုင်မာမှု — Ed25519 လက်မှတ်များသည် binary byte အကြမ်းများကို ကာမိပါသည်။ လက်မှတ်ထိုးထားသော binary ကို လက်မှတ် ပျက်ပြယ်စေခြင်းမရှိဘဲ ပြင်ဆင်၍ မရပါ။
- Sandbox ကျင့်သုံးခြင်း — Binary ပုံစံ စစ်ဆေးခြင်း (ELF/Mach-O/PE magic byte များ) သည် မြန်ဆန်ပြီး ယုံကြည်စိတ်ချရသော တံခါးစောင့် ဖြစ်သည်။
အမြန်စတင်ခြင်း
SDK ကို ထည့်သွင်းပါ
တရားဝင် SDK များသည် gRPC ဆာဗာ စနစ်ထည့်သွင်းခြင်း၊ signal ကိုင်တွယ်ခြင်းနှင့် protocol ချိတ်ဆက်ခြင်း အားလုံးကို ကိုင်တွယ်ပေးပါသည်။ သင်သည် handler interface များကိုသာ အကောင်အထည်ဖော်ရန် လိုပါသည်။
Go (အကြံပြုသည်)-
go get github.com/neboloop/nebo-sdk-go Rust (မကြာမီ ရောက်လာမည်)-
# Coming soon
[dependencies]
nebo-sdk = "0.1" C/C++ (မကြာမီ ရောက်လာမည်)-
# Coming soon — Add as a CMake subdirectory or copy headers from sdk/c/include/ အက်ပ် Directory ဖွဲ့စည်းပုံ
အက်ပ်များသည် သင့် Nebo ဒေတာ directory ၏ apps/ subdirectory ထဲတွင် ရှိပါသည်-
~/Library/Application Support/Nebo/apps/ # macOS
~/.config/nebo/apps/ # Linux
%AppData%\Nebo\apps\ # Windows
apps/
com.example.myapp/
manifest.json # Required: app metadata
binary # Required: executable (or named "app")
signatures.json # Required for NeboAI distribution, optional in dev
TOOL.md # Required: tool instructions for the agent
data/ # Auto-created: app's sandboxed storage
logs/ # Auto-created: stdout.log, stderr.log
ui/ # Optional: static UI assets (HTML/CSS/JS) အနည်းဆုံး အက်ပ် စစ်ဆေးရန်စာရင်း
id၊name၊version၊providesတို့ပါသောmanifest.jsonကို ဖန်တီးပါ- AI ဝန်ထမ်းက သင့်ကိရိယာကို မည်သို့ အသုံးပြုသင့်သည်ကို ဖော်ပြသော
TOOL.mdကို ရေးပါ - SDK ကို ထည့်သွင်းပါ (
go get github.com/neboloop/nebo-sdk-go) - သင့်စွမ်းရည်အတွက် handler interface ကို အကောင်အထည်ဖော်ပါ (
ToolHandler၊ChannelHandlerစသည်) - handler ကို မှတ်ပုံတင်ပြီး
app.Run()ကို ခေါ်ပါ - native binary ကို build လုပ်ပါ (
go build -o binary .) - binary + manifest.json + TOOL.md ကို
apps/<your-app-id>/directory ထဲတွင် ထားပါ - Nebo က ၎င်းကို အလိုအလျောက် ရှာဖွေပြီး စတင်ပါသည်
ဖွဲ့စည်းမှု
manifest.json
အက်ပ်တိုင်းတွင် manifest.json လိုအပ်ပါသည်-
{
"id": "com.example.myapp",
"name": "My App",
"version": "1.0.0",
"description": "What this app does",
"runtime": "local",
"protocol": "grpc",
"provides": ["tool:my_tool"],
"permissions": ["network:outbound"],
"settings": [
{
"key": "api_key",
"title": "API Key",
"type": "password",
"required": true,
"description": "Your API key for the service",
"secret": true
}
]
} လိုအပ်သော field များ-
| Field | ဖော်ပြချက် |
|---|---|
id | Reverse-domain အမှတ်အသား (ဥပမာ com.mycompany.myapp) |
name | လူဖတ်နိုင်သော အမည် |
version | Semver string |
provides | အနည်းဆုံး စွမ်းရည်တစ်ခု (အောက်တွင် ကြည့်ပါ) |
ရွေးချယ်နိုင်သော field များ-
| Field | ပုံသေ | ဖော်ပြချက် |
|---|---|---|
runtime | "local" | "local" သို့မဟုတ် "remote" |
protocol | "grpc" | "grpc" ကိုသာ ပံ့ပိုးသည် |
permissions | [] | အက်ပ် ဝင်ရောက်ရန် လိုအပ်သည့်အရာ |
description | "" | UI တွင် ပြသသည် |
settings | [] | ဖွဲ့စည်းနိုင်သော ဆက်တင်များ (ဆက်တင် UI တွင် ပြသသည်) |
oauth | [] | OAuth provider လိုအပ်ချက်များ (အောက်ပါ OAuth အပိုင်းကို ကြည့်ပါ) |
စွမ်းရည်များ
သင့်အက်ပ် ပေးသည့်အရာကို ကြေညာပါ-
| စွမ်းရည် | gRPC ဝန်ဆောင်မှု | ဖော်ပြချက် |
|---|---|---|
gateway | GatewayService | LLM မော်ဒယ် လမ်းကြောင်းသတ်မှတ်ခြင်း |
tool:<name> | ToolService | AI ဝန်ထမ်းအတွက် အမည်ပေးထားသော ကိရိယာ |
channel:<name> | ChannelService | မက်ဆေ့ချ်ပို့ ချန်နယ် |
comm | CommService | AI ဝန်ထမ်းများအကြား ဆက်သွယ်ရေး |
ui | UIService | HTTP proxy ပါသော စိတ်ကြိုက် UI |
schedule | ScheduleService | စိတ်ကြိုက် အချိန်ဇယားဆွဲခြင်း |
vision | ToolService | ရုပ်ပုံ စီမံဆောင်ရွက်ခြင်း |
browser | ToolService | Browser အလိုအလျောက်လုပ်ဆောင်ခြင်း |
အက်ပ်တစ်ခုသည် စွမ်းရည်များစွာ ပေးနိုင်ပါသည်။ ဥပမာ အက်ပ်တစ်ခုသည် ကိရိယာနှင့် UI panel နှစ်ခုလုံးကို ပေးနိုင်ပါသည်။
ခွင့်ပြုချက်များ
ခွင့်ပြုချက်များသည် အက်ပ် ဝင်ရောက်နိုင်သည့်အရာကို ထိန်းချုပ်ပါသည်။ ပုံသေအားဖြင့် ငြင်းပယ်သည် — မကြေညာထားပါက အက်ပ်သည် ၎င်းကို အသုံးမပြုနိုင်ပါ။
| Prefix | နမူနာများ | ဖော်ပြချက် |
|---|---|---|
network: | network:outbound၊ network:* | ကွန်ရက် ဝင်ရောက်ခွင့် |
filesystem: | filesystem:read၊ filesystem:write | ဖိုင်စနစ် ဝင်ရောက်ခွင့် |
memory: | memory:read၊ memory:write | AI ဝန်ထမ်း မှတ်ဉာဏ် ဝင်ရောက်ခွင့် |
session: | session:read | စကားပြောဆိုမှု session များ |
tool: | tool:shell၊ tool:file | အခြားကိရိယာများကို အသုံးပြုခြင်း |
shell: | shell:exec | Shell အမိန့် လုပ်ဆောင်ခြင်း |
channel: | channel:send၊ channel:* | ချန်နယ် လုပ်ဆောင်ချက်များ |
comm: | comm:send၊ comm:* | AI ဝန်ထမ်းများအကြား ဆက်သွယ်ရေး |
model: | model:chat | AI မော်ဒယ် ဝင်ရောက်ခွင့် |
user: | user:token | တောင်းဆိုချက်များတွင် အသုံးပြုသူ JWT ကို လက်ခံခြင်း |
schedule: | schedule:create | Cron job စီမံခြင်း |
database: | database:query | ဒေတာဘေ့စ် ဝင်ရောက်ခွင့် |
storage: | storage:read၊ storage:write | အမြဲတမ်း သိုလှောင်မှု |
context: | context:read | AI ဝန်ထမ်း အခြေအနေ ဝင်ရောက်ခွင့် |
subagent: | subagent:spawn | Sub-agent လုပ်ဆောင်ချက်များ |
lane: | lane:enqueue | Lane လုပ်ဆောင်ချက်များ |
notification: | notification:send | Push အသိပေးချက်များ |
embedding: | embedding:search | Vector embedding ဝင်ရောက်ခွင့် |
skill: | skill:invoke | ကျွမ်းကျင်မှု ခေါ်ယူခြင်း |
advisor: | advisor:consult | အကြံပေးစနစ် ဝင်ရောက်ခွင့် |
mcp: | mcp:connect | MCP ဆာဗာ ဝင်ရောက်ခွင့် |
voice: | voice:record | အသံ/အော်ဒီယို ဝင်ရောက်ခွင့် |
browser: | browser:navigate | Browser အလိုအလျောက်လုပ်ဆောင်ခြင်း |
oauth: | oauth:google၊ oauth:* | OAuth token ဝင်ရောက်ခွင့် |
settings: | settings:read | ဆက်တင်များ ဝင်ရောက်ခွင့် |
capability: | capability:register | စွမ်းရည် မှတ်ပုံတင်ခြင်း |
Wildcard ခွင့်ပြုချက်များကို ပံ့ပိုးပါသည်- network:* သည် မည်သည့် network: ခွင့်ပြုချက် စစ်ဆေးမှုနှင့်မဆို ကိုက်ညီပါသည်။
ဆက်တင်များ
ဆက်တင်များသည် Nebo UI ရှိ အက်ပ်၏ ဆက်တင် panel အောက်တွင် ပေါ်လာပါသည်။ Nebo က ၎င်းတို့ကို ဒေတာဘေ့စ်တွင် သိမ်းဆည်းပြီး ပြောင်းလဲသည့်အခါ Configure RPC မှတစ်ဆင့် သင့်အက်ပ်ထံ ပို့ပါသည်။
သင့်ဆက်တင် schema ကို NeboAI app store စာရင်းတွင် ထည့်သွင်းထားပါသည်။ လိုအပ်သော ဆက်တင်များ မဖွဲ့စည်းရသေးသော အက်ပ်များသည် UI တွင် "စနစ်ထည့်သွင်းရန် လိုအပ်သည်" တံဆိပ်ကို ပြသပါသည်။
| အမျိုးအစား | ဖော်ပြချက် |
|---|---|
text | တစ်ကြောင်းတည်း စာသား ထည့်သွင်းမှု |
password | ဖုံးကွယ်ထားသော စာသား ထည့်သွင်းမှု |
toggle | Boolean ဖွင့်/ပိတ် ခလုတ် |
select | ကြိုတင်သတ်မှတ်ထားသော ရွေးချယ်စရာများပါ dropdown |
number | ကိန်းဂဏန်း ထည့်သွင်းမှု |
url | စစ်ဆေးမှုပါသော URL ထည့်သွင်းမှု |
{
"key": "region",
"title": "Region",
"type": "select",
"required": true,
"default": "us-east-1",
"options": [
{"label": "US East", "value": "us-east-1"},
{"label": "EU West", "value": "eu-west-1"}
]
} OAuth လိုအပ်ချက်များ
အက်ပ်များသည် OAuth provider လိုအပ်ချက်များကို ကြေညာနိုင်ပါသည်။ Nebo ၏ OAuth broker က လုပ်ငန်းစဉ်တစ်ခုလုံးကို ကိုင်တွယ်ပေးပြီး အက်ပ်များသည် Configure RPC မှတစ်ဆင့် token များကို အလိုအလျောက် လက်ခံရရှိပါသည်။
{
"oauth": [
{
"provider": "google",
"scopes": ["https://www.googleapis.com/auth/calendar"]
}
]
} | Field | ဖော်ပြချက် |
|---|---|
provider | OAuth provider- "google"၊ "microsoft"၊ "github" |
scopes | အက်ပ်လိုအပ်သော OAuth scope များ၏ array |
အသုံးပြုသူက အက်ပ်ကို ထည့်သွင်းသည့်အခါ Nebo က လိုအပ်သော OAuth scope များကို ခွင့်ပြုရန် ၎င်းတို့ကို တောင်းဆိုပါသည်။ အက်ပ်သည် OAuth လုပ်ငန်းစဉ်ကို ကိုယ်တိုင် မကိုင်တွယ်ဘဲ Configure RPC မှတစ်ဆင့် ပြန်လည်ဆန်းသစ်ထားသော token များကို လက်ခံရရှိပါသည်။
Environment Variable များ
သင့်အက်ပ် process သည် သန့်စင်ထားသော environment ကို လက်ခံရရှိပါသည်။ လျှို့ဝှက်ချက် အားလုံးကို ဖယ်ရှားထားပါသည်။ သင် ရရှိသည်မှာ-
| Variable | တန်ဖိုး |
|---|---|
NEBO_APP_DIR | အက်ပ်၏ ထည့်သွင်းမှု directory |
NEBO_APP_SOCK | ဖန်တီးရမည့် Unix socket ၏ path |
NEBO_APP_ID | manifest မှ အက်ပ် ID |
NEBO_APP_NAME | manifest မှ အက်ပ် အမည် |
NEBO_APP_VERSION | manifest မှ အက်ပ် ဗားရှင်း |
NEBO_APP_DATA | အက်ပ်၏ data/ directory သို့ path |
PATH | စနစ် PATH (တိုက်ရိုက်ဖြတ်သန်း) |
HOME | အသုံးပြုသူ home directory (တိုက်ရိုက်ဖြတ်သန်း) |
TMPDIR | Temp directory (တိုက်ရိုက်ဖြတ်သန်း) |
အရေးကြီးသည်- သင့် binary သည် NEBO_APP_SOCK ရှိ Unix socket ပေါ်တွင် နားထောင်နေသော gRPC ဆာဗာကို ဖန်တီးရပါမည်။ Nebo သည် ဤ socket ပေါ်လာရန် 10 စက္ကန့်အထိ စောင့်ပါသည်။
အက်ပ် စတင်ခြင်း အစီအစဉ်
- Nebo က
manifest.jsonကို ဖတ်ပြီး စစ်ဆေးသည် - အက်ပ် directory ထဲတွင်
binaryသို့မဟုတ်appexecutable ကို ရှာသည် .quarantinedအမှတ်အသား ရှိမရှိ စစ်ဆေးသည် (quarantine လုပ်ထားသော အက်ပ်များကို စတင်ရန် ငြင်းဆိုသည်)- ရုပ်သိမ်းမှု စစ်ဆေးခြင်း (NeboAI မှ ဖြန့်ချိသော အက်ပ်များသာ)
- လက်မှတ် အတည်ပြုခြင်း (NeboAI မှ ဖြန့်ချိသော အက်ပ်များသာ၊ dev တွင် ကျော်သွားသည်)
- Binary စစ်ဆေးခြင်း (symlink များ၊ script များ၊ executable မဟုတ်သည်များ၊ အရွယ်အစား ကြီးလွန်းသော ဖိုင်များကို ငြင်းပယ်သည်)
- ယခင် လည်ပတ်မှုမှ ကျန်ခဲ့သော socket ဟောင်းကို ရှင်းလင်းသည်
- sandbox သိုလှောင်မှုအတွက်
data/directory ကို ဖန်တီးသည် - အက်ပ်တစ်ခုချင်းအလိုက် log ဖိုင်များကို စနစ်ထည့်သွင်းသည် (
logs/stdout.log၊logs/stderr.log) - သန့်စင်ထားသော environment နှင့် process group သီးခြားခွဲခြင်းဖြင့် binary ကို စတင်သည်
- Unix socket ပေါ်လာရန် စောင့်သည် (exponential backoff၊ အများဆုံး 10 စက္ကန့်)
- Unix socket ပေါ်မှ gRPC ဖြင့် ချိတ်ဆက်သည်
providesကို အခြေခံ၍ စွမ်းရည်အလိုက် gRPC client များကို ဖန်တီးသည်- ကျန်းမာရေး စစ်ဆေးမှုကို လုပ်ဆောင်သည်
- စွမ်းရည်များကို AI ဝန်ထမ်းထံ မှတ်ပုံတင်သည် (ကိရိယာများ၊ gateway၊ comm စသည်)
ကိရိယာ အက်ပ်များ
သင့် manifest တွင် "provides": ["tool:my_tool_name"] ကို ကြေညာပါ။
STRAP ပုံစံ
Nebo ကိရိယာ အက်ပ်အားလုံးသည် ၎င်းတို့၏ schema နှင့် လုပ်ဆောင်မှု လမ်းကြောင်းအတွက် STRAP (Single Tool Resource Action Pattern) ကို မဖြစ်မနေ အသုံးပြုရပါမည်။ ဤသည်မှာ Nebo က တစ်ခုချင်း ကိရိယာ 35+ ခုကို domain ကိရိယာ 4 ခုအဖြစ် ပေါင်းစည်းရန် အတွင်းပိုင်းတွင် အသုံးပြုသော ပုံစံတူ ဖြစ်ပြီး LLM context ဝန်ကို ~80% လျှော့ချပေးပါသည်။
အဓိက အယူအဆ- ကိရိယာများစွာ (get_events၊ check_availability၊ suggest_slots) ကို မှတ်ပုံတင်မည့်အစား မှန်ကန်သော handler သို့ လမ်းကြောင်းပေးသည့် action (နှင့် ရွေးချယ်နိုင်သော resource) field များပါသော ကိရိယာ တစ်ခုတည်းကို မှတ်ပုံတင်ပါ။
Resource တစ်ခုတည်း နမူနာ (ပြက္ခဒိန်)-
calendar(action: "get_events", start: "2025-01-15T09:00:00Z", end: "2025-01-16T00:00:00Z")
calendar(action: "next_event")
calendar(action: "check_availability", start: "...", end: "...")
calendar(action: "suggest_slots", duration_minutes: 30, preferred_time: "morning") Resource များစွာ နမူနာ (ပရောဂျက် မန်နေဂျာ)-
project(resource: "task", action: "create", title: "Ship v2", assignee: "alice")
project(resource: "task", action: "list", status: "open")
project(resource: "milestone", action: "create", name: "Beta", deadline: "2025-03-01")
project(resource: "milestone", action: "list") Schema စည်းမျဉ်းများ-
actionfield ကို လိုအပ်သော string enum အဖြစ် အမြဲ ထည့်ပါ- သင့်ကိရိယာက ကွဲပြားသော resource အမျိုးအစားများစွာကို စီမံမှသာ
resourcefield (လိုအပ်သော string enum) ကို ထည့်ပါ - အခြား field အားလုံးသည် action အလိုက် parameter များ ဖြစ်သည်
actionenum ဖော်ပြချက်တွင် ရရှိနိုင်သော action အားလုံးကို စာရင်းပြုစုသင့်သည်
STRAP အရေးကြီးရသည့် အကြောင်း-
- LLM များသည်
actionလမ်းကြောင်း ပုံစံကို တစ်ကြိမ် သင်ယူပြီး လုပ်ဆောင်ချက် အားလုံးတွင် ယေဘုယျ အသုံးချပါသည် - ကိရိယာ အဓိပ္ပာယ်ဖွင့်ဆိုချက်များသည် context ၏ ~6% ကို သုံးစွဲပြီး STRAP က ၎င်းကို 80% လျှော့ချပေးပါသည်
- လုပ်ဆောင်ချက်အသစ်များသည် ကိရိယာ မှတ်ပုံတင်ခြင်းအသစ် မဟုတ်ဘဲ enum ထပ်ထည့်ခြင်းသာ ဖြစ်သည်
- hosted နှင့် စက်တွင်း မော်ဒယ်များတွင် တူညီစွာ အလုပ်လုပ်သည်
Go နမူနာ — Calculator ကိရိယာ
package main
import (
"context"
"encoding/json"
"fmt"
"log"
nebo "github.com/neboloop/nebo-sdk-go"
)
type Calculator struct{}
func (c *Calculator) Name() string { return "calculator" }
func (c *Calculator) Description() string { return "Performs arithmetic calculations." }
func (c *Calculator) Schema() json.RawMessage {
return nebo.NewSchema("add", "subtract", "multiply", "divide").
Number("a", "First operand", true).
Number("b", "Second operand", true).
Build()
}
func (c *Calculator) Execute(_ context.Context, input json.RawMessage) (string, error) {
var in struct {
Action string `json:"action"`
A float64 `json:"a"`
B float64 `json:"b"`
}
if err := json.Unmarshal(input, &in); err != nil {
return "", fmt.Errorf("invalid input: %w", err)
}
var result float64
switch in.Action {
case "add":
result = in.A + in.B
case "subtract":
result = in.A - in.B
case "multiply":
result = in.A * in.B
case "divide":
if in.B == 0 {
return "", fmt.Errorf("division by zero")
}
result = in.A / in.B
default:
return "", fmt.Errorf("unknown action: %s", in.Action)
}
return fmt.Sprintf("%g %s %g = %g", in.A, in.Action, in.B, result), nil
}
func main() {
app, err := nebo.New()
if err != nil {
log.Fatal(err)
}
app.RegisterTool(&Calculator{})
log.Fatal(app.Run())
} manifest.json-
{
"id": "com.example.calculator",
"name": "Calculator",
"version": "1.0.0",
"description": "Arithmetic calculator tool for the agent",
"runtime": "local",
"protocol": "grpc",
"provides": ["tool:calculator"],
"permissions": []
} Build လုပ်ပြီး ထည့်သွင်းပါ-
go build -o binary .
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.calculator
cp binary manifest.json ~/Library/Application\ Support/Nebo/apps/com.example.calculator/ Rust နမူနာ
use async_trait::async_trait;
use nebo_sdk::{NeboApp, NeboError, SchemaBuilder};
use nebo_sdk::tool::ToolHandler;
use serde::Deserialize;
use serde_json::Value;
struct Calculator;
#[derive(Deserialize)]
struct Input { action: String, a: f64, b: f64 }
#[async_trait]
impl ToolHandler for Calculator {
fn name(&self) -> &str { "calculator" }
fn description(&self) -> &str { "Performs arithmetic calculations." }
fn schema(&self) -> Value {
SchemaBuilder::new(&["add", "subtract", "multiply", "divide"])
.number("a", "First operand", true)
.number("b", "Second operand", true)
.build()
}
async fn execute(&self, input: Value) -> Result<String, NeboError> {
let i: Input = serde_json::from_value(input)
.map_err(|e| NeboError::Execution(e.to_string()))?;
let r = match i.action.as_str() {
"add" => i.a + i.b,
"subtract" => i.a - i.b,
"multiply" => i.a * i.b,
"divide" => {
if i.b == 0.0 {
return Err(NeboError::Execution("division by zero".into()));
}
i.a / i.b
}
other => return Err(NeboError::Execution(format!("unknown action: {other}"))),
};
Ok(format!("{} {} {} = {}", i.a, i.action, i.b, r))
}
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
NeboApp::new()?.register_tool(Calculator).run().await?;
Ok(())
} C နမူနာ
#include <nebo/nebo.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static int calculator_execute(const char *input_json, char **output, int *is_error) {
/* Parse JSON, compute result, set *output */
*output = strdup("2 add 3 = 5");
*is_error = 0;
return 0;
}
int main(void) {
const char *actions[] = {"add", "subtract", "multiply", "divide", NULL};
nebo_schema_builder_t *sb = nebo_schema_new(actions);
nebo_schema_number(sb, "a", "First operand", 1);
nebo_schema_number(sb, "b", "Second operand", 1);
char *schema = nebo_schema_build(sb);
nebo_schema_free(sb);
nebo_tool_handler_t calculator = {
.name = "calculator",
.description = "Performs arithmetic calculations.",
.schema = schema,
.execute = calculator_execute,
};
nebo_app_t *app = nebo_app_new();
nebo_app_register_tool(app, &calculator);
int ret = nebo_app_run(app);
free(schema);
return ret;
} ချန်နယ် အက်ပ်များ
"provides": ["channel:my_channel"] နှင့် "permissions": ["channel:send"] ကို ကြေညာပါ။
ချန်နယ် အက်ပ်များသည် ပြင်ပ မက်ဆေ့ချ်ပို့ ပလက်ဖောင်းများ (Telegram၊ Discord၊ Slack စသည်) ကို Nebo ၏ AI ဝန်ထမ်းနှင့် ချိတ်ဆက်ပေးပါသည်။ အသုံးပြုသူက ပြင်ပ ပလက်ဖောင်းပေါ်တွင် မက်ဆေ့ချ်ပို့သည့်အခါ သင့်အက်ပ်က ၎င်းကို Receive မှတစ်ဆင့် Nebo ထံ stream လုပ်ပါသည်။ AI ဝန်ထမ်းက ပြန်ကြားလိုသည့်အခါ Nebo က သင့်အက်ပ်၏ Send ကို ခေါ်ပါသည်။
အလုပ်လုပ်ပုံ
- သင့်ချန်နယ်၏ သီးသန့် အမှတ်အသားကို ရယူရန် Nebo က
ID()ကို ခေါ်သည် - Nebo က သင့်အက်ပ်၏ ဆက်တင်များမှ config ဖြင့်
Connect()ကို ခေါ်သည် - Nebo က
Receive()stream ကို ဖွင့်သည် — အသုံးပြုသူက bot ထံ မက်ဆေ့ချ်ပို့တိုင်း သင့်အက်ပ်က အဝင်မက်ဆေ့ချ်များကို ပို့ပေးသည် - အဝင်မက်ဆေ့ချ်များကို AI ဝန်ထမ်း၏ အဓိက စကားပြောဆိုမှု lane သို့ လမ်းကြောင်းပေးသည်
- AI ဝန်ထမ်းက မက်ဆေ့ချ်ပို့လိုသည့်အခါ Nebo က v1 message envelope ဖြင့်
Send()ကို ခေါ်သည် - ပိတ်သိမ်းချိန်တွင် Nebo က
Disconnect()ကို ခေါ်သည်
v1 Message Envelope
ချန်နယ် မက်ဆေ့ချ်အားလုံး — အဝင်နှင့် အထွက် — သည် ဘုံ message envelope ကို အသုံးပြုသည်-
{
"message_id": "01953f8a-...",
"channel_id": "telegram:12345",
"sender": { "name": "Alex", "role": "COO", "bot_id": "uuid" },
"text": "Q3 numbers look good...",
"attachments": [{ "type": "image", "url": "https://...", "filename": "chart.png", "size": 45000 }],
"reply_to": "01953f89-...",
"actions": [{ "label": "Approve", "callback_id": "approve_q3" }],
"platform_data": null,
"timestamp": "2026-02-12T15:10:00Z"
} | Field | အမျိုးအစား | ဖော်ပြချက် |
|---|---|---|
message_id | UUID v7 | အချိန်အလိုက် စီထားသော သီးသန့် ID |
channel_id | {type}:{platform_id} | လမ်းကြောင်းပေးနိုင်သော ချန်နယ် အမှတ်အသား |
sender | object | Bot ကိုယ်ပိုင်အမှတ်အသား — name၊ role၊ botId |
text | string | မက်ဆေ့ချ် ကိုယ်ထည် |
attachments | array | ဖိုင်များ၊ ရုပ်ပုံများ၊ အော်ဒီယို |
reply_to | UUID v7 | Threading အတွက် မိခင် မက်ဆေ့ချ် ID |
actions | array | အပြန်အလှန် ခလုတ်များ/ကီးဘုတ်များ |
platform_data | bytes | ပလက်ဖောင်းအလိုက် လုပ်ဆောင်ချက်များအတွက် ပွင့်လင်းမြင်သာမှုမရှိသော တိုက်ရိုက်ဖြတ်သန်းမှု |
timestamp | ISO 8601 | ထုတ်ဝေသူက ဤအရာကို သတ်မှတ်သည် |
အလွှာနှစ်ထပ် ဒီဇိုင်း- ဘုံ field များ (text၊ attachments၊ reply_to၊ actions) သည် ဝန်ထမ်းက စတင်သော မက်ဆေ့ချ်ပို့ခြင်း၏ 90% ကို ကာမိပါသည်။ ပလက်ဖောင်းအလိုက် လုပ်ဆောင်ချက်များသည် platform_data ထဲသို့ ရောက်ပါသည် — သင့် plugin က ၎င်းတို့ကို native ပလက်ဖောင်း ပုံစံသို့/မှ ပြောင်းလဲပေးပါသည်။
စကားပြောဆိုမှု Stream များ
ချန်နယ် မက်ဆေ့ချ်များကို သီးခြားခွဲထားရန် ချန်နယ်အလိုက် စကားပြောဆိုမှု stream များပေါ်တွင် လမ်းကြောင်းပေးပါသည်-
neboai/bot/{botID}/channels/{channelType}/inbound # messages from users → agent
neboai/bot/{botID}/channels/{channelType}/outbound # messages from agent → channel Go နမူနာ — Telegram ချန်နယ်
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"time"
"github.com/google/uuid"
tgbot "github.com/go-telegram/bot"
nebo "github.com/neboloop/nebo-sdk-go"
)
type Telegram struct {
bot *tgbot.Bot
messages chan nebo.ChannelEnvelope
cancel context.CancelFunc
}
func (t *Telegram) ID() string { return "telegram" }
func (t *Telegram) Connect(_ context.Context, config map[string]string) error {
token := config["bot_token"]
if token == "" {
return fmt.Errorf("bot_token is required")
}
botCtx, cancel := context.WithCancel(context.Background())
t.cancel = cancel
bot, err := tgbot.New(token, tgbot.WithDefaultHandler(
func(bCtx context.Context, b *tgbot.Bot, update *tgbot.Update) {
if update.Message == nil {
return
}
env := nebo.ChannelEnvelope{
MessageID: uuid.Must(uuid.NewV7()).String(),
ChannelID: fmt.Sprintf("telegram:%d", update.Message.Chat.ID),
Text: update.Message.Text,
Timestamp: time.Unix(int64(update.Message.Date), 0).UTC(),
}
t.messages <- env
},
))
if err != nil {
return err
}
t.bot = bot
go bot.Start(botCtx)
return nil
}
func (t *Telegram) Send(ctx context.Context, env nebo.ChannelEnvelope) (string, error) {
if t.bot == nil {
return "", fmt.Errorf("not connected")
}
chatID := env.ChannelID[len("telegram:"):]
params := &tgbot.SendMessageParams{
ChatID: chatID,
Text: env.Text,
}
msg, err := t.bot.SendMessage(ctx, params)
if err != nil {
return "", err
}
return fmt.Sprintf("%d", msg.MessageID), nil
}
func (t *Telegram) Receive(_ context.Context) (<-chan nebo.ChannelEnvelope, error) {
return t.messages, nil
}
func (t *Telegram) Disconnect(_ context.Context) error {
if t.cancel != nil {
t.cancel()
}
return nil
}
func main() {
app, err := nebo.New()
if err != nil {
log.Fatal(err)
}
app.RegisterChannel(&Telegram{
messages: make(chan nebo.ChannelEnvelope, 100),
})
log.Fatal(app.Run())
} manifest.json-
{
"id": "com.example.telegram",
"name": "Telegram",
"version": "1.0.0",
"description": "Telegram messaging channel for Nebo",
"runtime": "local",
"protocol": "grpc",
"provides": ["channel:telegram"],
"permissions": ["channel:send", "network:outbound"],
"settings": [
{
"key": "bot_token",
"title": "Bot Token",
"type": "password",
"required": true,
"description": "Telegram bot token from @BotFather",
"secret": true
}
]
} နောက်ထပ် စွမ်းရည်များ
Comm အက်ပ်
"provides": ["comm"] နှင့် "permissions": ["comm:*"] ကို ကြေညာပါ။ Comm အက်ပ်များသည် AI ဝန်ထမ်းများအကြား ဆက်သွယ်ရေးကို ဖြစ်စေပါသည်။
| Field | ဖော်ပြချက် |
|---|---|
from | ပေးပို့သူ ဝန်ထမ်း ID |
to | လက်ခံသူ ဝန်ထမ်း ID |
topic | မက်ဆေ့ချ် ခေါင်းစဉ်/ချန်နယ် |
type | "message"၊ "mention"၊ "proposal"၊ "command"၊ "info"၊ "task" |
content | မက်ဆေ့ချ် ကိုယ်ထည် |
အဓိက အပြုအမူများ-
Registerသည် ဤ AI ဝန်ထမ်းကို ၎င်း၏ စွမ်းရည်များနှင့်အတူ ကွန်ရက်ပေါ်တွင် ကြေညာသည်Subscribe/Unsubscribeသည် ခေါင်းစဉ် subscription များကို စီမံသည်Receiveသည် အဝင်မက်ဆေ့ချ်များကို stream လုပ်သည် (server-streaming၊ ချန်နယ်များနှင့် အတူတူ)- တစ်ကြိမ်လျှင် comm အက်ပ် တစ်ခုသာ အသက်ဝင်နိုင်သည်
Gateway အက်ပ်
Gateway အက်ပ်သည် LLM တောင်းဆိုချက်များကို မော်ဒယ်များထံ လမ်းကြောင်းပေးပါသည်။ "provides": ["gateway"] နှင့် "permissions": ["network:outbound", "user:token"] ကို ကြေညာပါ။
GatewayRequest တွင် မက်ဆေ့ချ်များ၊ ကိရိယာများ၊ system prompt၊ max tokens၊ temperature နှင့် UserContext (user:token ခွင့်ပြုချက် ပေးထားပါက JWT token) ပါဝင်ပါသည်။
GatewayEvent အမျိုးအစားများ-
| အမျိုးအစား | အကြောင်းအရာ | ဖော်ပြချက် |
|---|---|---|
"text" | စာသား အပိုင်း | Streaming စာသား token |
"tool_call" | JSON | မော်ဒယ်က ကိရိယာကို ခေါ်လိုသည် |
"thinking" | စာသား အပိုင်း | တိုးချဲ့ စဉ်းစားခြင်း/ဆင်ခြင်ခြင်း |
"error" | အမှား မက်ဆေ့ချ် | တစ်ခုခု မှားယွင်းသွားသည် |
"done" | ဗလာ | Stream ပြီးဆုံးပါပြီ |
UI အက်ပ်
UI အက်ပ်သည် Nebo ၏ built-in browser ဝင်းဒိုးတွင် ပွင့်လာသော စိတ်ကြိုက် ဖွဲ့စည်းမှု အင်တာဖေ့စ်ကို ပေးပါသည်။ "provides": ["ui"] ကို ကြေညာပါ။ အလိုအလျောက် ဆက်တင်ဖောင် (Nebo က သင့် settings manifest မှ ပြသပေးသည်) နှင့် မတူဘဲ UI အက်ပ်သည် ၎င်း၏ ကိုယ်ပိုင် HTML/CSS/JS frontend အပြည့်အစုံကို ပေးပါသည်။
သင့်အက်ပ်တွင် static web asset များ (HTML၊ CSS၊ JS — ပုံမှန်အားဖြင့် index.html ပါသော SPA) ပါဝင်သည့် ui/ directory ပါလာပါသည်။ Nebo က ဤဖိုင်များကို တိုက်ရိုက် serve လုပ်ပြီး API ခေါ်ဆိုမှုများကို gRPC မှတစ်ဆင့် သင့်အက်ပ်ထံ proxy လုပ်ပါသည်။
| Path | လုပ်ဆောင်ပုံ | ရည်ရွယ်ချက် |
|---|---|---|
GET /api/v1/apps/{id}/ui/* | Static ဖိုင် ဆာဗာ | သင့် ui/ directory မှ ဖိုင်များကို serve လုပ်သည် (SPA fallback သည် index.html သို့) |
ANY /api/v1/apps/{id}/api/* | gRPC proxy | HTTP တောင်းဆိုချက်များကို သင့်အက်ပ်၏ UIService.HandleRequest() သို့ proxy လုပ်သည် |
SDK သည် စံ net/http.ServeMux ကို ထုပ်ပိုးထားသောကြောင့် သင်သည် ပုံမှန် Go HTTP handler များကို ရေးရုံသာ — SDK က gRPC ချိတ်ဆက်ခြင်းကို အလိုအလျောက် ကိုင်တွယ်ပေးပါသည်။
Go နမူနာ — Dashboard UI-
package main
import (
"encoding/json"
"log"
"net/http"
nebo "github.com/neboloop/nebo-sdk-go"
)
type Dashboard struct {
mux *http.ServeMux
}
func NewDashboard() *Dashboard {
d := &Dashboard{mux: http.NewServeMux()}
d.mux.HandleFunc("GET /status", func(w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
})
d.mux.HandleFunc("POST /action", func(w http.ResponseWriter, r *http.Request) {
var req map[string]string
json.NewDecoder(r.Body).Decode(&req)
json.NewEncoder(w).Encode(map[string]string{"result": "done"})
})
return d
}
func (d *Dashboard) Handler() *http.ServeMux { return d.mux }
func main() {
app, err := nebo.New()
if err != nil {
log.Fatal(err)
}
app.RegisterUI(NewDashboard())
log.Fatal(app.Run())
} သင့် ui/index.html သည် /api/v1/apps/com.example.dashboard/api/status သို့ fetch ခေါ်ဆိုမှုများ ပြုလုပ်မည်ဖြစ်ပြီး ၎င်းတို့ကို သင့် mux handler သို့ proxy လုပ်ပေးပါသည်။
အချိန်ဇယား အက်ပ်
အချိန်ဇယား အက်ပ်သည် Nebo ၏ built-in cron scheduler ကို အစားထိုးပါသည်။ "provides": ["schedule"] နှင့် "permissions": ["schedule:create"] ကို ကြေညာပါ။
သင့်အချိန်ဇယား အက်ပ် စတင်သည့်အခါ Nebo က ပုံသေ cron engine အစား အချိန်ဇယားဆွဲခြင်း အားလုံးကို သင့်အက်ပ်မှတစ်ဆင့် လမ်းကြောင်းပေးပါသည်။ သင့်အက်ပ် crash ဖြစ်ပါက Nebo သည် built-in engine သို့ အလိုအလျောက် ပြန်သွားပါသည်။
- သင့်အက်ပ်သည် အချိန်ဇယား အခြေအနေကို ပိုင်ဆိုင်သည် — အချိန်ဇယား အက်ပ် အသက်ဝင်နေစဉ် Nebo သည် အချိန်ဇယားများကို ၎င်း၏ကိုယ်ပိုင် DB တွင် မသိမ်းဆည်းပါ
- စံ CRUD-
Create၊Get၊List၊Update၊Delete၊Enable၊Disable Triggersသည် server-streaming RPC ဖြစ်သည် — အချိန်ဇယားတစ်ခု အစပျိုးတိုင်း သင့်အက်ပ်က trigger မက်ဆေ့ချ် ပို့သည်- တစ်ကြိမ်လျှင် အချိန်ဇယား အက်ပ် တစ်ခုသာ အသက်ဝင်နိုင်သည်
စွမ်းရည်များစွာပါ အက်ပ်များ
အက်ပ်တစ်ခုသည် စွမ်းရည်များစွာ ပေးနိုင်ပါသည်။ ဥပမာ ကိရိယာနှင့် UI နှစ်ခုလုံးပါသော dashboard အက်ပ်-
{
"id": "com.example.dashboard",
"name": "Dashboard",
"version": "1.0.0",
"provides": ["tool:dashboard_query", "ui"],
"permissions": ["network:outbound"]
} app, _ := nebo.New()
app.RegisterTool(&dashboardTool{})
app.RegisterUI(&dashboardUI{})
log.Fatal(app.Run()) ထုပ်ပိုးခြင်း
.napp ပုံစံ
NeboAI မှတစ်ဆင့် ဖြန့်ချိရန် သင့်အက်ပ်ကို .napp ဖိုင် (tar.gz archive) အဖြစ် ထုပ်ပိုးပါ-
cd com.example.myapp/
tar -czf myapp-1.0.0.napp manifest.json binary signatures.json TOOL.md လိုအပ်သော ဖိုင်များ-
| ဖိုင် | အများဆုံး အရွယ်အစား | ဖော်ပြချက် |
|---|---|---|
manifest.json | 1 MB | အက်ပ် metadata |
binary သို့မဟုတ် app | 500 MB | Executable |
signatures.json | 1 MB | Ed25519 လက်မှတ်များ |
TOOL.md | 1 MB | AI ဝန်ထမ်းအတွက် ကိရိယာ ညွှန်ကြားချက်များ |
ထုတ်ယူစဉ် လုံခြုံရေး စည်းမျဉ်းများ-
- Path traversal မရှိရ (
../ကို ငြင်းပယ်သည်) - Symlink မရှိရ (ငြင်းပယ်သည်)
- Absolute path မရှိရ (ငြင်းပယ်သည်)
- ခွင့်ပြုစာရင်းဝင် ဖိုင်အမည်များကိုသာ လက်ခံသည်
လက်မှတ်များ
NeboAI သည် အက်ပ်များကို Ed25519 ဖြင့် လက်မှတ်ထိုးပါသည်။ signatures.json ပုံစံ-
{
"key_id": "a1b2c3d4",
"algorithm": "ed25519",
"manifest_signature": "<base64 signature of raw manifest.json bytes>",
"binary_sha256": "<hex SHA256 of binary>",
"binary_signature": "<base64 signature of raw binary bytes>"
} Dev မုဒ်တွင် (NeboAI URL မဖွဲ့စည်းထားပါက) လက်မှတ် အတည်ပြုခြင်းကို လုံးဝ ကျော်သွားပါသည်။ စက်တွင်း ဖွံ့ဖြိုးရေးအတွက် signatures.json မလိုအပ်ပါ။
ထုတ်ဝေခြင်း
သင့်အက်ပ် စက်တွင်း၌ အလုပ်လုပ်ပြီဆိုလျှင် Nebo အသုံးပြုသူ အားလုံးထံ ဖြန့်ချိရန် NeboAI မှတစ်ဆင့် ထုတ်ဝေပါ။
ဆော့ဖ်ဝဲရေးသားသူ အကောင့် စနစ်ထည့်သွင်းခြင်း
POST /api/v1/owners/registerတွင် NeboAI အကောင့်ကို မှတ်ပုံတင်ပါ- JWT token ရယူရန် အကောင့်ဝင်ပါ-
POST /api/v1/owners/login - ဆော့ဖ်ဝဲရေးသားသူ အကောင့် ဖန်တီးပါ-
POST /api/v1/developer/accounts
တင်သွင်းခြင်း လုပ်ငန်းစဉ်
draft → pending_review → [approved] → published
→ [rejected] → draft (fix and resubmit) အဆင့် 1- အက်ပ်ကို ဖန်တီးပါ
curl -X POST https://neboai.com/api/v1/developer/apps \
-H "Authorization: Bearer $TOKEN" \
-H "Content-Type: application/json" \
-d '{
"name": "My App",
"version": "1.0.0",
"description": "What it does",
"category": "productivity",
"visibility": "public"
}' အဆင့် 2- ပလက်ဖောင်း binary များကို အပ်လုဒ်လုပ်ပါ
curl -X POST https://neboai.com/api/v1/developer/apps/{id}/binaries \
-H "Authorization: Bearer $TOKEN" \
-F "binary=@myapp-darwin-arm64" \
-F "platform=darwin-arm64" ပလက်ဖောင်းတစ်ခုလျှင် binary တစ်ခု အပ်လုဒ်လုပ်ပါ- darwin-arm64၊ darwin-amd64၊ linux-amd64၊ linux-arm64။
အဆင့် 3- စစ်ဆေးရန် တင်သွင်းပါ
curl -X POST https://neboai.com/api/v1/developer/apps/{id}/submit \
-H "Authorization: Bearer $TOKEN" စစ်ဆေးခြင်း လုပ်ငန်းစဉ်
- အလိုအလျောက် စကင်ဖတ်ခြင်း — binary များကို VirusTotal ဖြင့် စကင်ဖတ်သည်
- စီမံခန့်ခွဲသူ စစ်ဆေးခြင်း — NeboAI အဖွဲ့က metadata၊ manifest နှင့် စကင်ဖတ်ရလဒ်များကို စစ်ဆေးသည်
- အတည်ပြုသည့်အခါ — NeboAI က အက်ပ်ကို Ed25519 ဖြင့် လက်မှတ်ထိုးပြီး ထုတ်ဝေသည်
- ငြင်းပယ်သည့်အခါ — အကြောင်းရင်းကို သင် လက်ခံရရှိပြီး ပြင်ဆင်ကာ ပြန်လည်တင်သွင်းနိုင်သည်
ရည်မှန်းထားသော စစ်ဆေးချိန်- <24 နာရီ။
အပ်ဒိတ်များ ထုတ်ပေးခြင်း
- အက်ပ်၏ ဗားရှင်းကို အပ်ဒိတ်လုပ်ပါ– ဗားရှင်းအသစ်ဖြင့်
PUT /api/v1/developer/apps/{id} - ပလက်ဖောင်းတစ်ခုစီအတွက် binary အသစ်များကို အပ်လုဒ်လုပ်ပါ
- စစ်ဆေးရန် ထပ်မံ တင်သွင်းပါ
အပ်ဒိတ်တိုင်းသည် တူညီသော စစ်ဆေးခြင်း လုပ်ငန်းစဉ်ကို ဖြတ်သန်းရပါသည်။ ဗားရှင်းအသစ် အတည်ပြုမခံရမချင်း ယခင်ဗားရှင်းများ ဆက်လက် ရရှိနိုင်ပါသည်။
Store Metadata
| Field | ဖော်ပြချက် |
|---|---|
category | ဥပမာ productivity၊ communication၊ developer-tools |
icon | အက်ပ် icon URL |
visibility | public သို့မဟုတ် private |
description | manifest ဖော်ပြချက်ထက် ပိုရှည်/ပိုပြည့်စုံနိုင်သည် |
Dev လုပ်ငန်းစဉ်
စက်တွင်း ဖွံ့ဖြိုးရေး
စက်တွင်း ဖွံ့ဖြိုးရေးအတွက် ထုပ်ပိုးရန် မလိုပါ-
- သင့်အက်ပ် directory ကို ဖန်တီးပါ–
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp - သင့်
manifest.jsonနှင့် ကုဒ်ကို ရေးပါ - သင့် binary ကို build လုပ်ပါ–
go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary . - Nebo က directory အသစ်ကို အလိုအလျောက် တွေ့ရှိသည် (သို့မဟုတ် Nebo ကို ပြန်စပါ)
- ကုဒ် ပြောင်းလဲပြီးနောက် binary ကို ပြန် build လုပ်ပါ — file watcher က အက်ပ်ကို ပြန်စပေးပါမည်
Log များ ကြည့်ရှုခြင်း
အက်ပ် stdout/stderr ကို အက်ပ်တစ်ခုချင်းအလိုက် log ဖိုင်များတွင် ဖမ်းယူထားသည်-
tail -f ~/Library/Application\ Support/Nebo/apps/com.example.myapp/logs/stdout.log
tail -f ~/Library/Application\ Support/Nebo/apps/com.example.myapp/logs/stderr.log အမြဲတမ်း ဒေတာ
သင့်အက်ပ် ဆက်လက်ထိန်းသိမ်းရန် လိုအပ်သော ဖိုင်များအတွက် data/ directory (NEBO_APP_DATA env var အဖြစ်လည်း ရရှိနိုင်သည်) ကို အသုံးပြုပါ။ ဤ directory သည် အက်ပ် အပ်ဒိတ်များနှင့် quarantine ကို ကျော်လွန်၍ ကျန်ရှိနေပါသည်။
အမှားရှာဖွေရေး အကြံပြုချက်များ
- သင့်အက်ပ် မစတင်ပါက အမှားများအတွက်
logs/stderr.logကို စစ်ဆေးပါ - binary သည် executable ဖြစ်ကြောင်း သေချာပါစေ (
chmod +x binary) NEBO_APP_SOCKမှ Unix socket path ပေါ်တွင် နားထောင်နေကြောင်း သေချာပါစေ- socket သည် စတင်ပြီး 10 စက္ကန့်အတွင်း အသင့်ဖြစ်ရပါမည်
- သိုလှောင်မှုအတွက် hardcode လုပ်ထားသော path များမဟုတ်ဘဲ
NEBO_APP_DATAကို အသုံးပြုပါ - debug logging အတွက် stderr သို့ print လုပ်ပါ (
logs/stderr.logတွင် ဖမ်းယူထားသည်)
အတည်ပြုခြင်း
# List installed apps
nebo apps list
# Check running apps via the web UI Settings > Apps
# Or check the apps directory for running sockets
ls ~/Library/Application\ Support/Nebo/apps/*/app.sock ဖြုတ်ချခြင်း
nebo apps uninstall com.example.myapp ကျွမ်းကျင်မှုများ
ကျွမ်းကျင်မှုများ ဆိုသည်မှာ
ကျွမ်းကျင်မှုများသည် စကားပြောဆိုမှုအတွင်း Nebo ၏ အပြုအမူကို ပုံဖော်ပေးသော ညွှန်ကြားချက် အစုများ ဖြစ်သည်။ ကျွမ်းကျင်မှုတစ်ခု အသက်ဝင်နေသည့်အခါ ၎င်း၏ အကြောင်းအရာကို system prompt ထဲသို့ တိုက်ရိုက် ထည့်သွင်းပြီး ထို session အတွက် AI ဝန်ထမ်း၏ လေသံ၊ နည်းစနစ်၊ နယ်ပယ် ကျွမ်းကျင်မှုနှင့် ကိရိယာ အသုံးပြုပုံကို လမ်းညွှန်ပါသည်။
ကျွမ်းကျင်မှုများသည် ကုဒ် မဟုတ်ပါ။ ၎င်းတို့သည် YAML metadata ပါသော markdown စာရွက်စာတမ်းများ ဖြစ်သည်။ compile လုပ်ရန် မလို၊ binary မလို၊ gRPC မလိုပါ။ ကျွမ်းကျင်မှုတစ်ခုသည် directory တစ်ခုထဲရှိ SKILL.md ဖိုင်တစ်ခု ဖြစ်သည်။ ဒါပါပဲ။
ကျွမ်းကျင်မှုများသည် အခြေအနေအလိုက်ဖြစ်ပြီး ယာယီ ဖြစ်သည်။ ၎င်းတို့သည် သက်ဆိုင်သည့်အခါ (trigger ကိုက်ညီမှု သို့မဟုတ် လက်ဖြင့် load လုပ်ခြင်းဖြင့်) အသက်ဝင်ပြီး အလှည့်အနည်းငယ်ကြာ ဆက်ရှိကာ မလိုအပ်တော့သည့်အခါ သက်တမ်းကုန်ပါသည်။ ဤသို့ဖြင့် AI ဝန်ထမ်း၏ context ကို ပေါ့ပါးစေပါသည် — ယခု အရေးကြီးသော လမ်းညွှန်ချက်သာ prompt ထဲတွင် ရှိပါသည်။
ကျွမ်းကျင်မှုများသည် အက်ပ်များကို ဖြည့်စွက်ပေးပါသည်။ အက်ပ်များသည် လုပ်ဆောင်နိုင်သော စွမ်းရည်များ (ကိရိယာများ၊ ချန်နယ်များ၊ gateway များ) ကို ပေးပါသည်။ ကျွမ်းကျင်မှုများသည် စီမံညှိနှိုင်းရေး လမ်းညွှန်ချက် — ထိုကိရိယာများကို ထိရောက်စွာ အသုံးပြုပုံကို ပေးပါသည်။ ပြက္ခဒိန်အက်ပ်က Nebo ကို ဖြစ်ရပ်များ ဖတ်ရေးနိုင်သည့် စွမ်းရည် ပေးပါသည်။ "အစည်းအဝေး ပြင်ဆင်ခြင်း" ကျွမ်းကျင်မှုက ထိုပြက္ခဒိန်အက်ပ်၊ အီးမေးလ်နှင့် ဝဘ်ရှာဖွေမှုကို အတူတကွ အသုံးပြု၍ အစည်းအဝေးများအတွက် မည်သို့ ပြင်ဆင်ရမည်ကို Nebo ကို ပြောပြပါသည်။
ကျွမ်းကျင်မှုများနှင့် အက်ပ်များ နှိုင်းယှဉ်ချက်
| ကျွမ်းကျင်မှုများ | အက်ပ်များ | |
|---|---|---|
| ပုံစံ | Markdown (SKILL.md) | Compile လုပ်ထားသော binary (.napp) |
| Runtime | system prompt ထဲသို့ ထည့်သွင်းသည် | gRPC ပေါ်မှ sandbox လုပ်ထားသော process |
| ပေးသည့်အရာ | အပြုအမူ လမ်းညွှန်ချက်၊ နည်းစနစ် | ကိရိယာများ၊ ချန်နယ်များ၊ UI panel များ |
| သက်တမ်း | Session အတိုင်းအတာ၊ TTL အခြေပြု သက်တမ်းကုန်ခြင်း | အမြဲ လည်ပတ်နေသည် |
| ဖန်တီးခြင်း | markdown ဖိုင်တစ်ခု ရေးပါ | ရေး၊ compile၊ လက်မှတ်ထိုး၊ ထုပ်ပိုး |
| လုံခြုံရေး | ခွင့်ပြုချက် မလိုပါ | ပုံသေအားဖြင့် ငြင်းပယ်သော sandbox |
အမြန်စတင်ခြင်း
သင့် Nebo skills ဖိုလ်ဒါထဲတွင် SKILL.md ဖိုင်ပါသော directory တစ်ခု ဖန်တီးပါ-
~/Library/Application Support/Nebo/skills/ # macOS
~/.config/nebo/skills/ # Linux
%AppData%\Nebo\skills\ # Windows mkdir -p ~/.config/nebo/skills/my-skill SKILL.md တစ်ခု ရေးပါ-
---
name: my-skill
description: One-line description of what this skill does
version: "1.0.0"
triggers:
- keyword that activates this skill
- another trigger phrase
---
# My Skill
Instructions for Nebo when this skill is active.
Tell the agent what to do, how to approach problems,
what tools to use, and what tone to take. Nebo သည် skills directory ကို fsnotify ဖြင့် စောင့်ကြည့်ပါသည်။ သင့်ကျွမ်းကျင်မှုကို ချက်ချင်း အသုံးပြုနိုင်ပါသည် — ပြန်စရန် မလိုပါ။ trigger နှင့် ကိုက်ညီသည့် တစ်ခုခုကို ပြောလိုက်ပါက ၎င်း အလိုအလျောက် အသက်ဝင်ပါသည်။
သို့မဟုတ် Nebo ကို တိုက်ရိုက် မေးပါ- "ဘလော့ဂ်ပို့စ်ရေးဖို့ ကျွမ်းကျင်မှုတစ်ခု ဖန်တီးပေး" — Nebo က SKILL.md ဖိုင်ကို သင့်အတွက် ရေးပေးပါမည်။
SKILL.md ပုံစံ
ကျွမ်းကျင်မှုတိုင်းသည် အပိုင်းနှစ်ပိုင်းပါသော SKILL.md ဖိုင်တစ်ခုတည်း ဖြစ်သည်- --- အမှတ်အသားများကြားရှိ YAML frontmatter နှင့် markdown ကိုယ်ထည် (system prompt ထဲသို့ ထည့်သွင်းသော တကယ့် ညွှန်ကြားချက်များ)။
| Field | လိုအပ်သည် | ပုံသေ | ဖော်ပြချက် |
|---|---|---|---|
name | လိုသည် | — | သီးသန့် အမှတ်အသား (slug ဖြစ်လာသည်) |
description | လိုသည် | — | ကျွမ်းကျင်မှု catalog တွင် ပြသသော တစ်ကြောင်းတည်း ဖော်ပြချက် |
version | မလို | "1.0.0" | အပ်ဒိတ်များ ခြေရာခံရန် Semver |
author | မလို | — | ကျွမ်းကျင်မှု ရေးသားသူ |
priority | မလို | 0 | ပိုမြင့်လေ = ဦးစွာ ကိုက်ညီလေ (အရေးကြီး override များအတွက် 100+) |
max_turns | မလို | 4 | အလိုအလျောက် သက်တမ်းမကုန်မီ လှုပ်ရှားမှုမရှိသော အလှည့်များ |
triggers | မလို | [] | ဤကျွမ်းကျင်မှုကို အလိုအလျောက် အသက်ဝင်စေသော စကားစုများ (စာလုံးအကြီးအသေး မခွဲ substring ကိုက်ညီမှု) |
tools | မလို | [] | ဤကျွမ်းကျင်မှု အသုံးပြုရန် မျှော်လင့်ထားသော ကိရိယာများ (အချက်အလက်အတွက်သာ) |
dependencies | မလို | [] | ထည့်သွင်းထားရမည့် အခြား ကျွမ်းကျင်မှုများ |
tags | မလို | [] | အမျိုးအစားခွဲခြင်းနှင့် ရှာဖွေတွေ့ရှိခြင်းအတွက် |
platform | မလို | [] | ပံ့ပိုးထားသော ပလက်ဖောင်းများ- macos၊ linux၊ windows (ဗလာ = အားလုံး) |
ကျွမ်းကျင်မှုများ အသက်ဝင်ပုံ
ကျွမ်းကျင်မှုများသည် အဆင့်နှစ်ဆင့် အသက်ဝင်မှု ပုံစံကို လိုက်နာပါသည်- အရိပ်အမြွက်ပြပြီးမှ ခေါ်ယူခြင်း။
အဆင့် 1- Trigger ကိုက်ညီမှု — အသုံးပြုသူက မက်ဆေ့ချ်ပို့တိုင်း Nebo က မှတ်ပုံတင်ထားသော ကျွမ်းကျင်မှုအားလုံးကို trigger ကိုက်ညီမှုအတွက် စစ်ဆေးပါသည်။ ကိုက်ညီသော ကျွမ်းကျင်မှုများသည် system prompt တွင် အရိပ်အမြွက်များအဖြစ် ပေါ်လာပါသည်။ AI ဝန်ထမ်းက အရိပ်အမြွက်ကို မြင်ပြီး ကျွမ်းကျင်မှုကို ခေါ်ယူမည် မယူမည် ဆုံးဖြတ်ပါသည်။
အဆင့် 2- ခေါ်ယူခြင်း — AI ဝန်ထမ်းသည် အောက်ပါအတိုင်း ခေါ်ဆို၍ ကျွမ်းကျင်မှုကို ခေါ်ယူပါသည်-
skill(name: "code-review") ၎င်းသည် SKILL.md template အပြည့်အစုံကို ကိရိယာ ရလဒ်အဖြစ် ပြန်ပေးပြီး ခေါ်ယူမှုကို မှတ်တမ်းတင်ကာ နောက်ဆက်တွဲ အလှည့်များတွင် template ကို system prompt ထဲသို့ ပြန်လည် ထည့်သွင်းပါသည်။
TTL နှင့် သက်တမ်းကုန်ခြင်း-
- အလိုအလျောက် ကိုက်ညီသော ကျွမ်းကျင်မှုများ- လှုပ်ရှားမှုမရှိသော အလှည့် 4 ခု (
max_turnsဖြင့် ပြင်ဆင်နိုင်သည်) - လက်ဖြင့် load လုပ်ထားသော ကျွမ်းကျင်မှုများ- လှုပ်ရှားမှုမရှိသော အလှည့် 6 ခု
- ပြန်ခေါ်ယူခြင်းက timer ကို ပြန်စသည်
- တင်းကျပ်သော ကန့်သတ်ချက်- session တစ်ခုလျှင် အသက်ဝင်နေသော ကျွမ်းကျင်မှု အများဆုံး 4 ခု
- Token ဘတ်ဂျက်- အသက်ဝင်နေသော ကျွမ်းကျင်မှု အကြောင်းအရာ စုစုပေါင်းကို စာလုံး 16,000 ဖြင့် ကန့်သတ်ထားသည်
ကျွမ်းကျင်မှုများ စီမံခြင်း
AI ဝန်ထမ်းသည် skill ကိရိယာမှတစ်ဆင့် ကျွမ်းကျင်မှုများကို စီမံနိုင်ပါသည်-
| Action | ဖော်ပြချက် | နမူနာ |
|---|---|---|
catalog | ရရှိနိုင်သော ကျွမ်းကျင်မှုအားလုံးကို စာရင်းပြုစုသည် | skill(action: "catalog") |
load | ဤ session အတွက် အသက်သွင်းသည် | skill(name: "code-review", action: "load") |
unload | ကျွမ်းကျင်မှုကို ပိတ်သည် | skill(name: "code-review", action: "unload") |
create | disk ပေါ်တွင် ကျွမ်းကျင်မှုအသစ် ဖန်တီးသည် | skill(action: "create", content: "...") |
update | ရှိပြီးသား ကျွမ်းကျင်မှုကို အပ်ဒိတ်လုပ်သည် | skill(name: "my-skill", action: "update", content: "...") |
delete | disk ပေါ်မှ ကျွမ်းကျင်မှုကို ဖျက်သည် | skill(name: "my-skill", action: "delete") |
ကောင်းမွန်သော ကျွမ်းကျင်မှုများ ရေးသားခြင်း
ကောင်းမွန်သော ကျွမ်းကျင်မှု template တွင် ပါဝင်သည်မှာ-
- ရှင်းလင်းသော ခေါင်းစီး — AI ဝန်ထမ်းကို ၎င်း မည်သည့်မုဒ်တွင် ရှိနေသည်ကို ပြောပြသည်
- အဓိက အခြေခံမူများ — ညှိနှိုင်း၍မရသော အပြုအမူ စည်းမျဉ်းများ
- နည်းစနစ် — အဖြစ်များသော အခြေအနေများအတွက် အဆင့်လိုက် ချဉ်းကပ်ပုံ
- နမူနာများ — အသုံးပြုသူ မက်ဆေ့ချ်မှ တုံ့ပြန်ချက်သို့ တိကျသော ပုံစံများ
- ရှောင်ရန် ပုံစံများ — မလုပ်ရမည့်အရာ (မော်ဒယ်များသည် အနုတ်လက္ခဏာ နမူနာများမှ ကောင်းစွာ သင်ယူကြသည်)
အကြံပြုချက်- ကျွမ်းကျင်မှုတစ်ခုစီသည် အရာတစ်ခုကို ကောင်းကောင်း လုပ်သင့်ပါသည်။ "အထွေထွေ programming" ကျွမ်းကျင်မှု မဖန်တီးပါနှင့် — code-review၊ debugging၊ api-design ကို သီးခြား ကျွမ်းကျင်မှုများအဖြစ် ဖန်တီးပါ။ AI ဝန်ထမ်းတွင် တစ်ပြိုင်နက် အသက်ဝင်နေသော ကျွမ်းကျင်မှုများစွာ ရှိနိုင်ပါသည်။
ပါဝင်လာသော ကျွမ်းကျင်မှုများ
Nebo တွင် အဖြစ်များသော အသုံးပြုပုံများကို ကာမိသည့် ကျွမ်းကျင်မှုများ ပါဝင်လာပါသည်-
| ကျွမ်းကျင်မှု | ဦးစားပေးမှု | ဖော်ပြချက် |
|---|---|---|
onboarding | 100 | အသုံးပြုသူအသစ် နှုတ်ဆက်ခြင်းနှင့် ပရိုဖိုင် စုဆောင်းခြင်း |
best-friend | 50 | ကိုယ်ရည်ကိုယ်သွေး ကျွမ်းကျင်မှု — ပေါ့ပေါ့ပါးပါး၊ သစ္စာရှိ၊ ပွင့်ပွင့်လင်းလင်း ပြောဆိုခြင်း |
debugging | 25 | စနစ်တကျ အမှားရှာဖွေရေး နည်းစနစ် |
api-design | 15 | RESTful API ဒီဇိုင်း အကောင်းဆုံး အလေ့အကျင့်များ |
code-review | 10 | ပြင်းထန်မှုအဆင့်များပါ စနစ်တကျ ကုဒ်သုံးသပ်ခြင်း |
database-expert | 10 | ဒေတာဘေ့စ် ဒီဇိုင်း၊ query များ၊ optimization |
git-workflow | 10 | Git branching၊ commit များ၊ PR လုပ်ငန်းစဉ်များ |
security-audit | 10 | လုံခြုံရေး ခွဲခြမ်းစိတ်ဖြာခြင်းနှင့် အားနည်းချက် ရှာဖွေခြင်း |
ဤအရာများသည် အသုံးဝင်သော ပုံသေများအဖြစ်လည်းကောင်း၊ သင့်ကိုယ်ပိုင် ကျွမ်းကျင်မှုများ ဖန်တီးရန် ကိုးကားနိုင်သော အကောင်အထည်ဖော်မှုများအဖြစ်လည်းကောင်း အသုံးဝင်ပါသည်။
ကိုးကားချက်
Proto ဖိုင်များ
Proto ဖိုင်များသည် proto/apps/v0/ တွင် ရှိပါသည်။ SDK များတွင် ကြိုတင်ထုတ်လုပ်ထားသော ကုဒ် ပါဝင်လာသောကြောင့် ပုံမှန် ဖွံ့ဖြိုးရေးအတွက် protoc မလိုအပ်ပါ။
| ဖိုင် | ဝန်ဆောင်မှု | အဓိက RPC များ |
|---|---|---|
v0/common.proto | (မက်ဆေ့ချ်များသာ) | HealthCheckRequest/Response၊ SettingsMap၊ UserContext၊ Empty |
v0/tool.proto | ToolService | Name၊ Description၊ Schema၊ Execute၊ RequiresApproval၊ Configure |
v0/channel.proto | ChannelService | ID၊ Connect၊ Disconnect၊ Send၊ Receive (stream)၊ Configure |
v0/comm.proto | CommService | Name၊ Version၊ Connect၊ Disconnect၊ Send၊ Subscribe၊ Register၊ Receive (stream)၊ Configure |
v0/gateway.proto | GatewayService | HealthCheck၊ Stream (stream)၊ Poll၊ Cancel၊ Configure |
v0/ui.proto | UIService | HealthCheck၊ HandleRequest၊ Configure |
v0/schedule.proto | ScheduleService | HealthCheck၊ Create၊ Get၊ List၊ Update၊ Delete၊ Enable၊ Disable၊ Trigger၊ History၊ Triggers (stream)၊ Configure |
ဝန်ဆောင်မှုတိုင်းတွင် HealthCheck နှင့် Configure RPC များ ပါဝင်ပါသည်။ SDK က နှစ်ခုလုံးကို အလိုအလျောက် ကိုင်တွယ်ပေးပါသည်။
ချန်နယ် Proto အမျိုးအစားများ
| မက်ဆေ့ချ် အမျိုးအစား | ဖော်ပြချက် |
|---|---|
ChannelSendRequest | message_id၊ channelId၊ sender၊ text၊ attachments၊ reply_to၊ actions၊ platform_data ပါသော အထွက် message envelope |
ChannelSendResponse | Threading အတွက် ပလက်ဖောင်း မက်ဆေ့ချ် ID |
InboundMessage | ဘုံ field အားလုံး + timestamp ပါသော အဝင် message envelope |
MessageSender | Bot ကိုယ်ပိုင်အမှတ်အသား (name၊ role၊ botId) — broker က ဖြည့်စွက်ပေးသည် |
Attachment | ဖိုင်/ရုပ်ပုံ/အော်ဒီယို ပူးတွဲချက် (type၊ url၊ filename၊ size) |
MessageAction | အပြန်အလှန် ခလုတ်/ကီးဘုတ် action (label၊ callback_id) |
Bot ကိုယ်ပိုင်အမှတ်အသားနှင့် အခန်းကဏ္ဍများ
Nebo bot များတွင် ဝင်ရိုးသုံးခုပါ ကိုယ်ပိုင်အမှတ်အသား ပုံစံ ရှိပါသည်-
- creature — bot သည် ဘာလဲ (archetype)- "ဉာဏ်ထက်မြက်သော မဟာဗျူဟာရှင်"၊ "စေ့စပ်သေချာသော သုတေသီ"
- role — အသုံးပြုသူနှင့် ဆက်နွယ်ပုံ (ဆက်ဆံရေး)- "သူငယ်ချင်း"၊ "COO"၊ "လမ်းပြဆရာ"
- vibe — ၎င်း၏ စွမ်းအင် (ဆက်သွယ်ပုံ စတိုင်)- "အေးဆေးပေမဲ့ ကိုယ်ပိုင်အမြင်ရှိ"၊ "နွေးထွေးပြီး အားပေးတတ်"
သင့် ချန်နယ် plugin က အထွက်မက်ဆေ့ချ်ကို လက်ခံရရှိသည့်အခါ sender field တွင် bot ၏ name နှင့် role ပါဝင်ပါသည်။ သင့်ပလက်ဖောင်းအတွက် ပြသမည့်အမည်ကို ပုံစံချရန် ၎င်းကို အသုံးပြုပါ။ role သည် ရာထူးအမည် မဟုတ်ပါ — ဆက်ဆံရေးကို ဖော်ပြချက် ဖြစ်သည်။ "သူငယ်ချင်း"၊ "သား" နှင့် "လမ်းပြဆရာ" တို့သည် "COO" နှင့် "DevLead" တို့နှင့်အတူ မှန်ကန်သော role များ ဖြစ်ပါသည်။