NeboAI
NeboAI
စတင်ပါ

Nebo အတွက် အက်ပ်များ တည်ဆောက်ပါ

သင့် AI ကို စွမ်းအားထူးအသစ်များ ပေးပါ။ ကိရိယာများ၊ ချန်နယ်များ၊ gateway များ၊ UI panel များ — သင်စိတ်ကူးနိုင်သမျှ မည်သည့်အရာကိုမဆို native binary အဖြစ် compile လုပ်ပါ။

ခြုံငုံသုံးသပ်ချက်

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)

အနည်းဆုံး အက်ပ် စစ်ဆေးရန်စာရင်း

  1. id၊ name၊ version၊ provides တို့ပါသော manifest.json ကို ဖန်တီးပါ
  2. AI ဝန်ထမ်းက သင့်ကိရိယာကို မည်သို့ အသုံးပြုသင့်သည်ကို ဖော်ပြသော TOOL.md ကို ရေးပါ
  3. SDK ကို ထည့်သွင်းပါ (go get github.com/neboloop/nebo-sdk-go)
  4. သင့်စွမ်းရည်အတွက် handler interface ကို အကောင်အထည်ဖော်ပါ (ToolHandler၊ ChannelHandler စသည်)
  5. handler ကို မှတ်ပုံတင်ပြီး app.Run() ကို ခေါ်ပါ
  6. native binary ကို build လုပ်ပါ (go build -o binary .)
  7. binary + manifest.json + TOOL.md ကို apps/<your-app-id>/ directory ထဲတွင် ထားပါ
  8. 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ဖော်ပြချက်
idReverse-domain အမှတ်အသား (ဥပမာ com.mycompany.myapp)
nameလူဖတ်နိုင်သော အမည်
versionSemver string
providesအနည်းဆုံး စွမ်းရည်တစ်ခု (အောက်တွင် ကြည့်ပါ)

ရွေးချယ်နိုင်သော field များ-

Fieldပုံသေဖော်ပြချက်
runtime"local""local" သို့မဟုတ် "remote"
protocol"grpc""grpc" ကိုသာ ပံ့ပိုးသည်
permissions[]အက်ပ် ဝင်ရောက်ရန် လိုအပ်သည့်အရာ
description""UI တွင် ပြသသည်
settings[]ဖွဲ့စည်းနိုင်သော ဆက်တင်များ (ဆက်တင် UI တွင် ပြသသည်)
oauth[]OAuth provider လိုအပ်ချက်များ (အောက်ပါ OAuth အပိုင်းကို ကြည့်ပါ)

စွမ်းရည်များ

သင့်အက်ပ် ပေးသည့်အရာကို ကြေညာပါ-

စွမ်းရည်gRPC ဝန်ဆောင်မှုဖော်ပြချက်
gatewayGatewayServiceLLM မော်ဒယ် လမ်းကြောင်းသတ်မှတ်ခြင်း
tool:<name>ToolServiceAI ဝန်ထမ်းအတွက် အမည်ပေးထားသော ကိရိယာ
channel:<name>ChannelServiceမက်ဆေ့ချ်ပို့ ချန်နယ်
commCommServiceAI ဝန်ထမ်းများအကြား ဆက်သွယ်ရေး
uiUIServiceHTTP proxy ပါသော စိတ်ကြိုက် UI
scheduleScheduleServiceစိတ်ကြိုက် အချိန်ဇယားဆွဲခြင်း
visionToolServiceရုပ်ပုံ စီမံဆောင်ရွက်ခြင်း
browserToolServiceBrowser အလိုအလျောက်လုပ်ဆောင်ခြင်း

အက်ပ်တစ်ခုသည် စွမ်းရည်များစွာ ပေးနိုင်ပါသည်။ ဥပမာ အက်ပ်တစ်ခုသည် ကိရိယာနှင့် UI panel နှစ်ခုလုံးကို ပေးနိုင်ပါသည်။

ခွင့်ပြုချက်များ

ခွင့်ပြုချက်များသည် အက်ပ် ဝင်ရောက်နိုင်သည့်အရာကို ထိန်းချုပ်ပါသည်။ ပုံသေအားဖြင့် ငြင်းပယ်သည် — မကြေညာထားပါက အက်ပ်သည် ၎င်းကို အသုံးမပြုနိုင်ပါ။

Prefixနမူနာများဖော်ပြချက်
network:network:outbound၊ network:*ကွန်ရက် ဝင်ရောက်ခွင့်
filesystem:filesystem:read၊ filesystem:writeဖိုင်စနစ် ဝင်ရောက်ခွင့်
memory:memory:read၊ memory:writeAI ဝန်ထမ်း မှတ်ဉာဏ် ဝင်ရောက်ခွင့်
session:session:readစကားပြောဆိုမှု session များ
tool:tool:shell၊ tool:fileအခြားကိရိယာများကို အသုံးပြုခြင်း
shell:shell:execShell အမိန့် လုပ်ဆောင်ခြင်း
channel:channel:send၊ channel:*ချန်နယ် လုပ်ဆောင်ချက်များ
comm:comm:send၊ comm:*AI ဝန်ထမ်းများအကြား ဆက်သွယ်ရေး
model:model:chatAI မော်ဒယ် ဝင်ရောက်ခွင့်
user:user:tokenတောင်းဆိုချက်များတွင် အသုံးပြုသူ JWT ကို လက်ခံခြင်း
schedule:schedule:createCron job စီမံခြင်း
database:database:queryဒေတာဘေ့စ် ဝင်ရောက်ခွင့်
storage:storage:read၊ storage:writeအမြဲတမ်း သိုလှောင်မှု
context:context:readAI ဝန်ထမ်း အခြေအနေ ဝင်ရောက်ခွင့်
subagent:subagent:spawnSub-agent လုပ်ဆောင်ချက်များ
lane:lane:enqueueLane လုပ်ဆောင်ချက်များ
notification:notification:sendPush အသိပေးချက်များ
embedding:embedding:searchVector embedding ဝင်ရောက်ခွင့်
skill:skill:invokeကျွမ်းကျင်မှု ခေါ်ယူခြင်း
advisor:advisor:consultအကြံပေးစနစ် ဝင်ရောက်ခွင့်
mcp:mcp:connectMCP ဆာဗာ ဝင်ရောက်ခွင့်
voice:voice:recordအသံ/အော်ဒီယို ဝင်ရောက်ခွင့်
browser:browser:navigateBrowser အလိုအလျောက်လုပ်ဆောင်ခြင်း
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ဖုံးကွယ်ထားသော စာသား ထည့်သွင်းမှု
toggleBoolean ဖွင့်/ပိတ် ခလုတ်
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ဖော်ပြချက်
providerOAuth 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_IDmanifest မှ အက်ပ် ID
NEBO_APP_NAMEmanifest မှ အက်ပ် အမည်
NEBO_APP_VERSIONmanifest မှ အက်ပ် ဗားရှင်း
NEBO_APP_DATAအက်ပ်၏ data/ directory သို့ path
PATHစနစ် PATH (တိုက်ရိုက်ဖြတ်သန်း)
HOMEအသုံးပြုသူ home directory (တိုက်ရိုက်ဖြတ်သန်း)
TMPDIRTemp directory (တိုက်ရိုက်ဖြတ်သန်း)

အရေးကြီးသည်- သင့် binary သည် NEBO_APP_SOCK ရှိ Unix socket ပေါ်တွင် နားထောင်နေသော gRPC ဆာဗာကို ဖန်တီးရပါမည်။ Nebo သည် ဤ socket ပေါ်လာရန် 10 စက္ကန့်အထိ စောင့်ပါသည်။

အက်ပ် စတင်ခြင်း အစီအစဉ်

  1. Nebo က manifest.json ကို ဖတ်ပြီး စစ်ဆေးသည်
  2. အက်ပ် directory ထဲတွင် binary သို့မဟုတ် app executable ကို ရှာသည်
  3. .quarantined အမှတ်အသား ရှိမရှိ စစ်ဆေးသည် (quarantine လုပ်ထားသော အက်ပ်များကို စတင်ရန် ငြင်းဆိုသည်)
  4. ရုပ်သိမ်းမှု စစ်ဆေးခြင်း (NeboAI မှ ဖြန့်ချိသော အက်ပ်များသာ)
  5. လက်မှတ် အတည်ပြုခြင်း (NeboAI မှ ဖြန့်ချိသော အက်ပ်များသာ၊ dev တွင် ကျော်သွားသည်)
  6. Binary စစ်ဆေးခြင်း (symlink များ၊ script များ၊ executable မဟုတ်သည်များ၊ အရွယ်အစား ကြီးလွန်းသော ဖိုင်များကို ငြင်းပယ်သည်)
  7. ယခင် လည်ပတ်မှုမှ ကျန်ခဲ့သော socket ဟောင်းကို ရှင်းလင်းသည်
  8. sandbox သိုလှောင်မှုအတွက် data/ directory ကို ဖန်တီးသည်
  9. အက်ပ်တစ်ခုချင်းအလိုက် log ဖိုင်များကို စနစ်ထည့်သွင်းသည် (logs/stdout.log၊ logs/stderr.log)
  10. သန့်စင်ထားသော environment နှင့် process group သီးခြားခွဲခြင်းဖြင့် binary ကို စတင်သည်
  11. Unix socket ပေါ်လာရန် စောင့်သည် (exponential backoff၊ အများဆုံး 10 စက္ကန့်)
  12. Unix socket ပေါ်မှ gRPC ဖြင့် ချိတ်ဆက်သည်
  13. provides ကို အခြေခံ၍ စွမ်းရည်အလိုက် gRPC client များကို ဖန်တီးသည်
  14. ကျန်းမာရေး စစ်ဆေးမှုကို လုပ်ဆောင်သည်
  15. စွမ်းရည်များကို 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 စည်းမျဉ်းများ-

  1. action field ကို လိုအပ်သော string enum အဖြစ် အမြဲ ထည့်ပါ
  2. သင့်ကိရိယာက ကွဲပြားသော resource အမျိုးအစားများစွာကို စီမံမှသာ resource field (လိုအပ်သော string enum) ကို ထည့်ပါ
  3. အခြား field အားလုံးသည် action အလိုက် parameter များ ဖြစ်သည်
  4. action enum ဖော်ပြချက်တွင် ရရှိနိုင်သော 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 ကို ခေါ်ပါသည်။

အလုပ်လုပ်ပုံ

  1. သင့်ချန်နယ်၏ သီးသန့် အမှတ်အသားကို ရယူရန် Nebo က ID() ကို ခေါ်သည်
  2. Nebo က သင့်အက်ပ်၏ ဆက်တင်များမှ config ဖြင့် Connect() ကို ခေါ်သည်
  3. Nebo က Receive() stream ကို ဖွင့်သည် — အသုံးပြုသူက bot ထံ မက်ဆေ့ချ်ပို့တိုင်း သင့်အက်ပ်က အဝင်မက်ဆေ့ချ်များကို ပို့ပေးသည်
  4. အဝင်မက်ဆေ့ချ်များကို AI ဝန်ထမ်း၏ အဓိက စကားပြောဆိုမှု lane သို့ လမ်းကြောင်းပေးသည်
  5. AI ဝန်ထမ်းက မက်ဆေ့ချ်ပို့လိုသည့်အခါ Nebo က v1 message envelope ဖြင့် Send() ကို ခေါ်သည်
  6. ပိတ်သိမ်းချိန်တွင် 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_idUUID v7အချိန်အလိုက် စီထားသော သီးသန့် ID
channel_id{type}:{platform_id}လမ်းကြောင်းပေးနိုင်သော ချန်နယ် အမှတ်အသား
senderobjectBot ကိုယ်ပိုင်အမှတ်အသား — name၊ role၊ botId
textstringမက်ဆေ့ချ် ကိုယ်ထည်
attachmentsarrayဖိုင်များ၊ ရုပ်ပုံများ၊ အော်ဒီယို
reply_toUUID v7Threading အတွက် မိခင် မက်ဆေ့ချ် ID
actionsarrayအပြန်အလှန် ခလုတ်များ/ကီးဘုတ်များ
platform_databytesပလက်ဖောင်းအလိုက် လုပ်ဆောင်ချက်များအတွက် ပွင့်လင်းမြင်သာမှုမရှိသော တိုက်ရိုက်ဖြတ်သန်းမှု
timestampISO 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 proxyHTTP တောင်းဆိုချက်များကို သင့်အက်ပ်၏ 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.json1 MBအက်ပ် metadata
binary သို့မဟုတ် app500 MBExecutable
signatures.json1 MBEd25519 လက်မှတ်များ
TOOL.md1 MBAI ဝန်ထမ်းအတွက် ကိရိယာ ညွှန်ကြားချက်များ

ထုတ်ယူစဉ် လုံခြုံရေး စည်းမျဉ်းများ-

  • 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 မှတစ်ဆင့် ထုတ်ဝေပါ။

ဆော့ဖ်ဝဲရေးသားသူ အကောင့် စနစ်ထည့်သွင်းခြင်း

  1. POST /api/v1/owners/register တွင် NeboAI အကောင့်ကို မှတ်ပုံတင်ပါ
  2. JWT token ရယူရန် အကောင့်ဝင်ပါ- POST /api/v1/owners/login
  3. ဆော့ဖ်ဝဲရေးသားသူ အကောင့် ဖန်တီးပါ- 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"

စစ်ဆေးခြင်း လုပ်ငန်းစဉ်

  1. အလိုအလျောက် စကင်ဖတ်ခြင်း — binary များကို VirusTotal ဖြင့် စကင်ဖတ်သည်
  2. စီမံခန့်ခွဲသူ စစ်ဆေးခြင်း — NeboAI အဖွဲ့က metadata၊ manifest နှင့် စကင်ဖတ်ရလဒ်များကို စစ်ဆေးသည်
  3. အတည်ပြုသည့်အခါ — NeboAI က အက်ပ်ကို Ed25519 ဖြင့် လက်မှတ်ထိုးပြီး ထုတ်ဝေသည်
  4. ငြင်းပယ်သည့်အခါ — အကြောင်းရင်းကို သင် လက်ခံရရှိပြီး ပြင်ဆင်ကာ ပြန်လည်တင်သွင်းနိုင်သည်

ရည်မှန်းထားသော စစ်ဆေးချိန်- <24 နာရီ။

အပ်ဒိတ်များ ထုတ်ပေးခြင်း

  1. အက်ပ်၏ ဗားရှင်းကို အပ်ဒိတ်လုပ်ပါ– ဗားရှင်းအသစ်ဖြင့် PUT /api/v1/developer/apps/{id}
  2. ပလက်ဖောင်းတစ်ခုစီအတွက် binary အသစ်များကို အပ်လုဒ်လုပ်ပါ
  3. စစ်ဆေးရန် ထပ်မံ တင်သွင်းပါ

အပ်ဒိတ်တိုင်းသည် တူညီသော စစ်ဆေးခြင်း လုပ်ငန်းစဉ်ကို ဖြတ်သန်းရပါသည်။ ဗားရှင်းအသစ် အတည်ပြုမခံရမချင်း ယခင်ဗားရှင်းများ ဆက်လက် ရရှိနိုင်ပါသည်။

Store Metadata

Fieldဖော်ပြချက်
categoryဥပမာ productivity၊ communication၊ developer-tools
iconအက်ပ် icon URL
visibilitypublic သို့မဟုတ် private
descriptionmanifest ဖော်ပြချက်ထက် ပိုရှည်/ပိုပြည့်စုံနိုင်သည်

Dev လုပ်ငန်းစဉ်

စက်တွင်း ဖွံ့ဖြိုးရေး

စက်တွင်း ဖွံ့ဖြိုးရေးအတွက် ထုပ်ပိုးရန် မလိုပါ-

  1. သင့်အက်ပ် directory ကို ဖန်တီးပါ–
    mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp
  2. သင့် manifest.json နှင့် ကုဒ်ကို ရေးပါ
  3. သင့် binary ကို build လုပ်ပါ–
    go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary .
  4. Nebo က directory အသစ်ကို အလိုအလျောက် တွေ့ရှိသည် (သို့မဟုတ် Nebo ကို ပြန်စပါ)
  5. ကုဒ် ပြောင်းလဲပြီးနောက် 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)
Runtimesystem 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")
createdisk ပေါ်တွင် ကျွမ်းကျင်မှုအသစ် ဖန်တီးသည်skill(action: "create", content: "...")
updateရှိပြီးသား ကျွမ်းကျင်မှုကို အပ်ဒိတ်လုပ်သည်skill(name: "my-skill", action: "update", content: "...")
deletedisk ပေါ်မှ ကျွမ်းကျင်မှုကို ဖျက်သည်skill(name: "my-skill", action: "delete")

ကောင်းမွန်သော ကျွမ်းကျင်မှုများ ရေးသားခြင်း

ကောင်းမွန်သော ကျွမ်းကျင်မှု template တွင် ပါဝင်သည်မှာ-

  1. ရှင်းလင်းသော ခေါင်းစီး — AI ဝန်ထမ်းကို ၎င်း မည်သည့်မုဒ်တွင် ရှိနေသည်ကို ပြောပြသည်
  2. အဓိက အခြေခံမူများ — ညှိနှိုင်း၍မရသော အပြုအမူ စည်းမျဉ်းများ
  3. နည်းစနစ် — အဖြစ်များသော အခြေအနေများအတွက် အဆင့်လိုက် ချဉ်းကပ်ပုံ
  4. နမူနာများ — အသုံးပြုသူ မက်ဆေ့ချ်မှ တုံ့ပြန်ချက်သို့ တိကျသော ပုံစံများ
  5. ရှောင်ရန် ပုံစံများ — မလုပ်ရမည့်အရာ (မော်ဒယ်များသည် အနုတ်လက္ခဏာ နမူနာများမှ ကောင်းစွာ သင်ယူကြသည်)

အကြံပြုချက်- ကျွမ်းကျင်မှုတစ်ခုစီသည် အရာတစ်ခုကို ကောင်းကောင်း လုပ်သင့်ပါသည်။ "အထွေထွေ programming" ကျွမ်းကျင်မှု မဖန်တီးပါနှင့် — code-review၊ debugging၊ api-design ကို သီးခြား ကျွမ်းကျင်မှုများအဖြစ် ဖန်တီးပါ။ AI ဝန်ထမ်းတွင် တစ်ပြိုင်နက် အသက်ဝင်နေသော ကျွမ်းကျင်မှုများစွာ ရှိနိုင်ပါသည်။

ပါဝင်လာသော ကျွမ်းကျင်မှုများ

Nebo တွင် အဖြစ်များသော အသုံးပြုပုံများကို ကာမိသည့် ကျွမ်းကျင်မှုများ ပါဝင်လာပါသည်-

ကျွမ်းကျင်မှုဦးစားပေးမှုဖော်ပြချက်
onboarding100အသုံးပြုသူအသစ် နှုတ်ဆက်ခြင်းနှင့် ပရိုဖိုင် စုဆောင်းခြင်း
best-friend50ကိုယ်ရည်ကိုယ်သွေး ကျွမ်းကျင်မှု — ပေါ့ပေါ့ပါးပါး၊ သစ္စာရှိ၊ ပွင့်ပွင့်လင်းလင်း ပြောဆိုခြင်း
debugging25စနစ်တကျ အမှားရှာဖွေရေး နည်းစနစ်
api-design15RESTful API ဒီဇိုင်း အကောင်းဆုံး အလေ့အကျင့်များ
code-review10ပြင်းထန်မှုအဆင့်များပါ စနစ်တကျ ကုဒ်သုံးသပ်ခြင်း
database-expert10ဒေတာဘေ့စ် ဒီဇိုင်း၊ query များ၊ optimization
git-workflow10Git branching၊ commit များ၊ PR လုပ်ငန်းစဉ်များ
security-audit10လုံခြုံရေး ခွဲခြမ်းစိတ်ဖြာခြင်းနှင့် အားနည်းချက် ရှာဖွေခြင်း

ဤအရာများသည် အသုံးဝင်သော ပုံသေများအဖြစ်လည်းကောင်း၊ သင့်ကိုယ်ပိုင် ကျွမ်းကျင်မှုများ ဖန်တီးရန် ကိုးကားနိုင်သော အကောင်အထည်ဖော်မှုများအဖြစ်လည်းကောင်း အသုံးဝင်ပါသည်။

ကိုးကားချက်

Proto ဖိုင်များ

Proto ဖိုင်များသည် proto/apps/v0/ တွင် ရှိပါသည်။ SDK များတွင် ကြိုတင်ထုတ်လုပ်ထားသော ကုဒ် ပါဝင်လာသောကြောင့် ပုံမှန် ဖွံ့ဖြိုးရေးအတွက် protoc မလိုအပ်ပါ။

ဖိုင်ဝန်ဆောင်မှုအဓိက RPC များ
v0/common.proto(မက်ဆေ့ချ်များသာ)HealthCheckRequest/Response၊ SettingsMap၊ UserContext၊ Empty
v0/tool.protoToolServiceName၊ Description၊ Schema၊ Execute၊ RequiresApproval၊ Configure
v0/channel.protoChannelServiceID၊ Connect၊ Disconnect၊ Send၊ Receive (stream)၊ Configure
v0/comm.protoCommServiceName၊ Version၊ Connect၊ Disconnect၊ Send၊ Subscribe၊ Register၊ Receive (stream)၊ Configure
v0/gateway.protoGatewayServiceHealthCheck၊ Stream (stream)၊ Poll၊ Cancel၊ Configure
v0/ui.protoUIServiceHealthCheck၊ HandleRequest၊ Configure
v0/schedule.protoScheduleServiceHealthCheck၊ Create၊ Get၊ List၊ Update၊ Delete၊ Enable၊ Disable၊ Trigger၊ History၊ Triggers (stream)၊ Configure

ဝန်ဆောင်မှုတိုင်းတွင် HealthCheck နှင့် Configure RPC များ ပါဝင်ပါသည်။ SDK က နှစ်ခုလုံးကို အလိုအလျောက် ကိုင်တွယ်ပေးပါသည်။

ချန်နယ် Proto အမျိုးအစားများ

မက်ဆေ့ချ် အမျိုးအစားဖော်ပြချက်
ChannelSendRequestmessage_id၊ channelId၊ sender၊ text၊ attachments၊ reply_to၊ actions၊ platform_data ပါသော အထွက် message envelope
ChannelSendResponseThreading အတွက် ပလက်ဖောင်း မက်ဆေ့ချ် ID
InboundMessageဘုံ field အားလုံး + timestamp ပါသော အဝင် message envelope
MessageSenderBot ကိုယ်ပိုင်အမှတ်အသား (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 များ ဖြစ်ပါသည်။