NeboAI
NeboAI
Bẹ̀rẹ̀

Kọ́ Àwọn Áàpù fún Nebo

Fún AI rẹ ní agbára àrà tuntun. Àwọn irinṣẹ́, ìkànnì, gateway, pánẹ́ẹ̀lì UI — ohunkóhun tí o lè ronú kàn, tí a ṣàkójọ sí binary àbínibí.

Àkópọ̀

Kí Ni Nebo Jẹ́

Nebo jẹ́ olùrànlọ́wọ́ AI ti ara ẹni lórí kọ̀ǹpútà — òṣìṣẹ́ AI tí ń ṣiṣẹ́ nígbà gbogbo tí ó ń ṣàkóso ìgbésí ayé oní-nọ́ńbà rẹ. Ronú nípa Nebo bí o ṣe ń ronú nípa fóònù alágbèéká: pẹpẹ alágbára tí ó ń di ohun ìyípadà ńlá nípasẹ̀ àwọn áàpù rẹ̀.

Fúnra rẹ̀, Nebo jẹ́ òṣìṣẹ́ AI tí ó mọṣẹ́ pẹ̀lú ìrántí, ìṣètò àkókò, lílọ kiri wẹ́ẹ̀bù, ìṣàkóso fáìlì, àti ààyè sí shell. Ṣùgbọ́n kọ́kọ́rọ́ gidi ni Àwọn áàpù. Gẹ́gẹ́ bí agbára fóònù alágbèéká ṣe ń wá láti inú àyíká áàpù rẹ̀, agbára Nebo ń wá láti inú àwọn áàpù tí ó ń fẹ ohun tí ó lè ṣe lójú.

Kí Ni Àwọn Áàpù Jẹ́

Àwọn áàpù Nebo jẹ́ ẹ̀ka tí ó dá dúró, tí a ti ṣàkójọ tẹ́lẹ̀, tí ó ní iṣẹ́ àrà ọ̀tọ̀. Áàpù kọ̀ọ̀kan ń fún Nebo ní agbára àrà tuntun — ìṣàkóso kàlẹ́ńdà, ìṣètò ímeèlì, títọpa iṣẹ́ àkànṣe, ìṣiṣẹ́ ilé aládàáṣe, àtúpalẹ̀ ìṣúná — ohunkóhun tí olùgbéejáde lè ronú kàn.

Àwọn áàpù ń pèsè agbára àrà ní ọ̀nà tí ó ní ààbò gidigidi. Gbogbo áàpù ń ṣiṣẹ́ nínú sandbox pẹ̀lú àwọn àṣẹ tí a kọ̀ ní ìpìlẹ̀. Ó lè dé ohun tí manifest rẹ̀ kéde tí olùlò sì fọwọ́ sí nìkan.

Ìbáṣepọ̀ náà jẹ́ ìjíròrò ní 100%. Àwọn olùlò kì í lo àwọn áàpù nípasẹ̀ ojú-ìwé tàbí dashboard ọ̀tọ̀. Wọ́n ń bá Nebo sọ̀rọ̀, Nebo sì ń lo àwọn irinṣẹ́ áàpù náà láti ṣe iṣẹ́. "Kí ló wà lórí kàlẹ́ńdà mi lọ́la?" — Nebo pe áàpù kàlẹ́ńdà. "Ṣẹ̀dá ìpàdé pẹ̀lú Sarah ní 3pm" — Nebo pe áàpù kàlẹ́ńdà. Olùlò kì í kúrò nínú ìjíròrò rárá.

Àwọn áàpù lè pèsè UI ètò bí wọ́n bá fẹ́ — pánẹ́ẹ̀lì ìṣètò tí ó ń ṣí nínú fèrèsé aṣàwákiri tí a kọ́ sínú Nebo. Ibẹ̀ ni àwọn olùlò ti ń tẹ àwọn kọ́kọ́rọ́ API, tan tàbí pa àwọn ẹ̀yà, tí wọ́n sì ń ṣètò áàpù náà. Àkójọ settings nínú manifest ló ń darí UI ètò náà (Nebo ń ṣe fọ́ọ̀mù náà fúnra rẹ̀), tàbí kí áàpù náà pèsè UI àdáni tirẹ̀ ní kíkún nípasẹ̀ agbára ui.

Àwọn áàpù ń rọ́pò àwọn agbára tí a kọ́ sínú Nebo, wọ́n sì ń fẹ̀ wọ́n lójú. Nebo ń jáde pẹ̀lú àwọn irinṣẹ́ pẹpẹ ìpìlẹ̀ (ààyè sí kàlẹ́ńdà orí ẹ̀rọ, àwòrán ojú-ìwé, àti bẹ́ẹ̀ bẹ́ẹ̀ lọ). Nígbà tí o bá fi áàpù kàlẹ́ńdà sórí ẹ̀rọ, yóò rọ́pò irinṣẹ́ kàlẹ́ńdà tí a kọ́ sínú rẹ̀, yóò sì di èyí tí ó ní gbogbo rẹ̀ àti jù bẹ́ẹ̀ lọ — orí ẹ̀rọ + cloud + àkójọpọ̀ + ṣíṣàyẹ̀wò àyè.

Ìlànà Ṣíṣàkójọ Nìkan

Nebo ń mú ìlànà binary tí a ṣàkójọ nìkan ṣẹ ní kíkankíkan. Gbogbo áàpù gbọ́dọ̀ jẹ́ fáìlì aláṣẹ àbínibí tí a ṣàkójọ.

IpòÀwọn èdè
Tí a ṣe àtìlẹ́yìn fúnGo (tí a dámọ̀ràn), Rust, C/C++, Zig
Tí a kọ̀Python, Node.js, Ruby, Java, .NET, àwọn script shell

Ìdí:

  • Dídènà AI láti yí ara rẹ̀ padà — Òṣìṣẹ́ AI tí ó ní ààyè sí shell lè yí ìwà script tí a ń túmọ̀ padà nígbà tí ó ń ṣiṣẹ́. Àwọn binary tí a ṣàkójọ kò ṣeé yí padà lẹ́yìn ìfọwọ́sí.
  • Ìdúróṣinṣin ìfọwọ́sí — Àwọn ìfọwọ́sí Ed25519 ń bo àwọn báìtì binary gidi. A kò lè yí binary tí a fọwọ́ sí padà láìsọ ìfọwọ́sí náà di asán.
  • Ìmúṣẹ sandbox — Ìfọwọ́sí ìrísí binary (àwọn báìtì àmì ELF/Mach-O/PE) jẹ́ ẹnu-ọ̀nà tí ó yára tí ó sì ṣeé gbẹ́kẹ̀lé.

Ìbẹ̀rẹ̀ kíákíá

Fi SDK sórí ẹ̀rọ

Àwọn SDK oníṣẹ́ ń bójú tó gbogbo ìṣètò sáfà gRPC, ìbójútó àmì, àti afárá ìlànà. Ìwọ kàn ń ṣe àwọn interface handler.

Go (tí a dámọ̀ràn):

go get github.com/neboloop/nebo-sdk-go

Rust (ń bọ̀ láìpẹ́):

# Coming soon
[dependencies]
nebo-sdk = "0.1"

C/C++ (ń bọ̀ láìpẹ́):

# Coming soon — Add as a CMake subdirectory or copy headers from sdk/c/include/

Ìtòlẹ́sẹẹsẹ Fódà Áàpù

Àwọn áàpù ń gbé inú fódà kékeré apps/ nínú fódà dátà Nebo rẹ:

~/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)

Àtòjọ Àyẹ̀wò Áàpù Kékeré Jù

  1. Ṣẹ̀dá manifest.json pẹ̀lú id, name, version, provides
  2. Kọ TOOL.md tí ó ń ṣàpèjúwe bí òṣìṣẹ́ AI ṣe yẹ kí ó lo irinṣẹ́ rẹ
  3. Fi SDK sórí ẹ̀rọ (go get github.com/neboloop/nebo-sdk-go)
  4. Ṣe interface handler fún agbára rẹ (ToolHandler, ChannelHandler, àti bẹ́ẹ̀ bẹ́ẹ̀ lọ)
  5. Forúkọ handler náà sílẹ̀ kí o sì pe app.Run()
  6. Kọ́ binary àbínibí (go build -o binary .)
  7. Fi binary + manifest.json + TOOL.md sínú fódà apps/<your-app-id>/
  8. Nebo yóò ṣàwárí rẹ̀ fúnra rẹ̀, yóò sì ṣí i

Ìṣètò

manifest.json

Gbogbo áàpù nílò 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
        }
    ]
}

Àwọn pápá tí ó pọn dandan:

PápáÀpèjúwe
idÌdámọ̀ ìkápá-ìdàkejì (bí àpẹẹrẹ, com.mycompany.myapp)
nameOrúkọ tí ènìyàn lè kà
versionOkùn semver
providesÓ kéré tán agbára kan (wo nísàlẹ̀)

Àwọn pápá àṣàyàn:

PápáÌpìlẹ̀Àpèjúwe
runtime"local""local" tàbí "remote"
protocol"grpc""grpc" nìkan ni a ṣe àtìlẹ́yìn fún
permissions[]Ohun tí áàpù náà nílò ààyè sí
description""Ó ń hàn nínú UI
settings[]Àwọn ètò tí a lè ṣàtúnṣe (tí a fi hàn nínú UI Ètò)
oauth[]Àwọn ìbéèrè olùpèsè OAuth (wo apá OAuth nísàlẹ̀)

Àwọn agbára

Kéde ohun tí áàpù rẹ ń pèsè:

AgbáraIṣẹ́ gRPCÀpèjúwe
gatewayGatewayServiceDídarí àwòṣe LLM
tool:<name>ToolServiceIrinṣẹ́ tí ó ní orúkọ fún òṣìṣẹ́ AI
channel:<name>ChannelServiceÌkànnì ìfiránṣẹ́
commCommServiceÌbánisọ̀rọ̀ láàárín àwọn òṣìṣẹ́ AI
uiUIServiceUI àdáni pẹ̀lú HTTP proxy
scheduleScheduleServiceÌṣètò àkókò àdáni
visionToolServiceṢíṣe iṣẹ́ lórí àwòrán
browserToolServiceÌṣiṣẹ́ aṣàwákiri aládàáṣe

Áàpù kan lè pèsè ọ̀pọ̀ agbára. Bí àpẹẹrẹ, áàpù kan lè pèsè irinṣẹ́ àti pánẹ́ẹ̀lì UI papọ̀.

Àwọn àṣẹ

Àwọn àṣẹ ń ṣàkóso ohun tí áàpù náà lè dé. A kọ̀ ọ́ ní ìpìlẹ̀ — bí a kò bá kéde rẹ̀, áàpù náà kò lè lò ó.

Ìbẹ̀rẹ̀ ọ̀rọ̀Àwọn àpẹẹrẹÀpèjúwe
network:network:outbound, network:*Ààyè sí nẹ́tíwọ́ọ̀kì
filesystem:filesystem:read, filesystem:writeÀàyè sí ètò fáìlì
memory:memory:read, memory:writeÀàyè sí ìrántí òṣìṣẹ́ AI
session:session:readÀwọn ìgbà ìjíròrò
tool:tool:shell, tool:fileLo àwọn irinṣẹ́ míì
shell:shell:execṢíṣe àṣẹ shell
channel:channel:send, channel:*Àwọn iṣẹ́ ìkànnì
comm:comm:send, comm:*Ìbánisọ̀rọ̀ láàárín àwọn òṣìṣẹ́ AI
model:model:chatÀàyè sí àwòṣe AI
user:user:tokenGba JWT olùlò nínú àwọn ìbéèrè
schedule:schedule:createÌṣàkóso iṣẹ́ cron
database:database:queryÀàyè sí ibi ìpamọ́ dátà
storage:storage:read, storage:writeIbi ìpamọ́ tí ó wà pẹ́
context:context:readÀàyè sí àyíká òṣìṣẹ́ AI
subagent:subagent:spawnÀwọn iṣẹ́ sub-agent
lane:lane:enqueueÀwọn iṣẹ́ lane
notification:notification:sendÀwọn ìfitónilétí push
embedding:embedding:searchÀàyè sí vector embedding
skill:skill:invokePípe ọgbọ́n
advisor:advisor:consultÀàyè sí ètò olùgbaninímọ̀ràn
mcp:mcp:connectÀàyè sí sáfà MCP
voice:voice:recordÀàyè sí ohùn/ìró
browser:browser:navigateÌṣiṣẹ́ aṣàwákiri aládàáṣe
oauth:oauth:google, oauth:*Ààyè sí token OAuth
settings:settings:readÀàyè sí ètò
capability:capability:registerÌforúkọsílẹ̀ agbára

A ṣe àtìlẹ́yìn fún àwọn àṣẹ wildcard: network:* bá gbogbo àyẹ̀wò àṣẹ network: mu.

Ètò

Àwọn ètò ń hàn nínú UI Nebo lábẹ́ pánẹ́ẹ̀lì ètò áàpù náà. Nebo ń tọ́jú wọn sínú ibi ìpamọ́ dátà, ó sì ń fi wọ́n ránṣẹ́ sí áàpù rẹ nípasẹ̀ RPC Configure nígbà tí wọ́n bá yí padà.

Àwòṣe ètò rẹ wà nínú àkọsílẹ̀ ilé ìtajà áàpù NeboAI. Àwọn áàpù tí ó ní ètò tí ó pọn dandan tí a kò tíì ṣètò ń fi àmì "Needs Setup" hàn nínú UI.

IrúÀpèjúwe
textÀpótí ọ̀rọ̀ ìlà kan
passwordÀpótí ọ̀rọ̀ tí a fi pamọ́
toggleBọ́tìnnì tàn/pa Boolean
selectÀtòjọ ìyànsílẹ̀ pẹ̀lú àwọn àṣàyàn tí a ti ṣètò
numberÀpótí nọ́mbà
urlÀpótí URL pẹ̀lú àyẹ̀wò
{
    "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"}
    ]
}

Àwọn Ìbéèrè OAuth

Àwọn áàpù lè kéde àwọn ìbéèrè olùpèsè OAuth. Alágbàtà OAuth ti Nebo ń bójú tó gbogbo ìlànà náà — àwọn áàpù ń gba àwọn token fúnra wọn nípasẹ̀ RPC Configure.

{
    "oauth": [
        {
            "provider": "google",
            "scopes": ["https://www.googleapis.com/auth/calendar"]
        }
    ]
}
PápáÀpèjúwe
providerOlùpèsè OAuth: "google", "microsoft", "github"
scopesÀkójọ àwọn scope OAuth tí áàpù náà nílò

Nígbà tí olùlò bá fi áàpù náà sórí ẹ̀rọ, Nebo yóò ní kí wọ́n fún àwọn scope OAuth tí ó pọn dandan láṣẹ. Áàpù náà ń gba àwọn token tí a sọ dọ̀tun nípasẹ̀ RPC Configure láìní láti bójú tó ìlànà OAuth fúnra rẹ̀.

Àwọn Àyípadà Àyíká

Ìlànà áàpù rẹ ń gba àyíká tí a ti fọ̀ mọ́. A yọ gbogbo àṣírí kúrò. Ohun tí o ń gbà ni:

ÀyípadàIye
NEBO_APP_DIRFódà ìfisórí-ẹ̀rọ áàpù náà
NEBO_APP_SOCKỌ̀nà sí Unix socket tí a ó ṣẹ̀dá
NEBO_APP_IDID áàpù láti inú manifest
NEBO_APP_NAMEOrúkọ áàpù láti inú manifest
NEBO_APP_VERSIONẸ̀dà áàpù láti inú manifest
NEBO_APP_DATAỌ̀nà sí fódà data/ áàpù náà
PATHPATH ètò (tí a gbé kọjá)
HOMEFódà ilé olùlò (tí a gbé kọjá)
TMPDIRFódà ìgbà díẹ̀ (tí a gbé kọjá)

Pàtàkì: Binary rẹ gbọ́dọ̀ ṣẹ̀dá sáfà gRPC tí ń gbọ́ lórí Unix socket ní NEBO_APP_SOCK. Nebo ń dúró títí dé ìṣẹ́jú-àáyá 10 kí socket yìí tó fara hàn.

Ìtòlẹ́sẹẹsẹ Ìṣísílẹ̀ Áàpù

  1. Nebo ka manifest.json, ó sì ṣàyẹ̀wò rẹ̀
  2. Ó wá fáìlì aláṣẹ binary tàbí app nínú fódà áàpù náà
  3. Ó ṣàyẹ̀wò fún àmì .quarantined (ó kọ̀ láti ṣí àwọn áàpù tí a yà sọ́tọ̀)
  4. Àyẹ̀wò ìfagilé (àwọn áàpù tí NeboAI pín nìkan)
  5. Ìfìdímúlẹ̀ ìfọwọ́sí (àwọn áàpù tí NeboAI pín nìkan, a fò ó nínú dev)
  6. Àyẹ̀wò binary (ó kọ symlink, script, àwọn tí kì í ṣe fáìlì aláṣẹ, àwọn fáìlì tí ó tóbi jù)
  7. Ó pa socket àtijọ́ láti ìṣiṣẹ́ tó kọjá rẹ́
  8. Ó ṣẹ̀dá fódà data/ fún ibi ìpamọ́ inú sandbox
  9. Ó ṣètò àwọn fáìlì àkọsílẹ̀ fún áàpù kọ̀ọ̀kan (logs/stdout.log, logs/stderr.log)
  10. Ó bẹ̀rẹ̀ binary pẹ̀lú àyíká tí a ti fọ̀ mọ́ àti ìyàsọ́tọ̀ ẹgbẹ́ ìlànà
  11. Ó dúró kí Unix socket fara hàn (exponential backoff, ìṣẹ́jú-àáyá 10 ní pọ̀ jù)
  12. Ó sopọ̀ nípasẹ̀ gRPC lórí Unix socket
  13. Ó ṣẹ̀dá àwọn oníbàárà gRPC fún agbára kọ̀ọ̀kan gẹ́gẹ́ bí provides
  14. Ó ṣe àyẹ̀wò ìlera
  15. Ó forúkọ àwọn agbára sílẹ̀ pẹ̀lú òṣìṣẹ́ AI (àwọn irinṣẹ́, gateway, comm, àti bẹ́ẹ̀ bẹ́ẹ̀ lọ)

Àwọn Áàpù Irinṣẹ́

Kéde "provides": ["tool:my_tool_name"] nínú manifest rẹ.

Àpẹẹrẹ STRAP

Gbogbo áàpù irinṣẹ́ Nebo gbọ́dọ̀ lo STRAP (Single Tool Resource Action Pattern) fún àwòṣe wọn àti dídarí ìṣiṣẹ́. Èyí ni àpẹẹrẹ kan náà tí Nebo ń lò nínú láti kó irinṣẹ́ ẹyọ-ẹyọ tí ó ju 35 lọ pọ̀ sí irinṣẹ́ ìkápá 4 — ó ń dín ẹrù àyíká LLM kù ní ~80%.

Èrò pàtàkì: Dípò fífi orúkọ ọ̀pọ̀ irinṣẹ́ sílẹ̀ (get_events, check_availability, suggest_slots), forúkọ irinṣẹ́ KAN sílẹ̀ pẹ̀lú àwọn pápá action (àti resource bí o bá fẹ́) tí ó ń darí sí handler tí ó tọ́.

Àpẹẹrẹ ohun-èlò kan (kàlẹ́ńdà):

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")

Àpẹẹrẹ ọ̀pọ̀ ohun-èlò (olùṣàkóso iṣẹ́ àkànṣe):

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")

Àwọn òfin àwòṣe:

  1. Máa fi pápá action sí i nígbà gbogbo gẹ́gẹ́ bí string enum tí ó pọn dandan
  2. Fi pápá resource (string enum tí ó pọn dandan) kún un kìkì bí irinṣẹ́ rẹ bá ń ṣàkóso ọ̀pọ̀ irú ohun-èlò tí ó yàtọ̀
  3. Gbogbo àwọn pápá míì jẹ́ àwọn paramita fún action pàtó
  4. Àpèjúwe enum action yẹ kí ó ṣe àtòjọ gbogbo action tí ó wà

Ìdí tí STRAP fi ṣe pàtàkì:

  • Àwọn LLM ń kọ́ àpẹẹrẹ dídarí action lẹ́ẹ̀kan, wọ́n sì ń lò ó fún gbogbo iṣẹ́
  • Àwọn ìtumọ̀ irinṣẹ́ ń jẹ ~6% àyíká — STRAP ń gé e kù ní 80%
  • Àwọn iṣẹ́ tuntun jẹ́ àfikún enum lásán, kì í ṣe ìforúkọsílẹ̀ irinṣẹ́ tuntun
  • Ó ń ṣiṣẹ́ bákan náà lórí àwọn àwòṣe tí a gbé sórí ayélujára àti ti orí ẹ̀rọ

Àpẹẹrẹ Go — Irinṣẹ́ Ẹ̀rọ Ìṣirò

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": []
}

Kọ́ ọ kí o sì fi sórí ẹ̀rọ:

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/

Àpẹẹrẹ 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(())
}

Àpẹẹrẹ 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;
}

Àwọn Áàpù Ìkànnì

Kéde "provides": ["channel:my_channel"] àti "permissions": ["channel:send"].

Àwọn áàpù ìkànnì ń so àwọn pẹpẹ ìfiránṣẹ́ òde (Telegram, Discord, Slack, àti bẹ́ẹ̀ bẹ́ẹ̀ lọ) pọ̀ mọ́ òṣìṣẹ́ AI ti Nebo. Nígbà tí olùlò bá fi ìránṣẹ́ ránṣẹ́ lórí pẹpẹ òde náà, áàpù rẹ yóò ṣàn án sí Nebo nípasẹ̀ Receive. Nígbà tí òṣìṣẹ́ AI bá fẹ́ fèsì, Nebo yóò pe Send áàpù rẹ.

Bí ó ṣe ń ṣiṣẹ́

  1. Nebo pe ID() láti gba ìdámọ̀ àrà ọ̀tọ̀ ìkànnì rẹ
  2. Nebo pe Connect() pẹ̀lú ìṣètò láti inú ètò áàpù rẹ
  3. Nebo ṣí ìṣàn Receive() — áàpù rẹ ń fi àwọn ìránṣẹ́ tí ó wọlé ránṣẹ́ nígbàkígbà tí olùlò bá fi ìránṣẹ́ ránṣẹ́ sí bot náà
  4. A ń darí àwọn ìránṣẹ́ tí ó wọlé sí lane ìjíròrò pàtàkì òṣìṣẹ́ AI
  5. Nígbà tí òṣìṣẹ́ AI bá fẹ́ fi ìránṣẹ́ ránṣẹ́, Nebo pe Send() pẹ̀lú àpò-ìwé ìránṣẹ́ v1
  6. Nígbà tí a bá ń pa á, Nebo pe Disconnect()

Àpò-ìwé Ìránṣẹ́ v1

Gbogbo ìránṣẹ́ ìkànnì — tí ó wọlé àti tí ó jáde — ń lo àpò-ìwé ìránṣẹ́ àjọlò:

{
  "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"
}
PápáIrúÀpèjúwe
message_idUUID v7ID àrà ọ̀tọ̀ tí a tò ní ìtẹ̀léra àkókò
channel_id{type}:{platform_id}Ìdámọ̀ ìkànnì tí a lè darí
senderobjectÌdánimọ̀ bot — orúkọ, ipa, botId
textstringAra ìránṣẹ́
attachmentsarrayÀwọn fáìlì, àwòrán, ìró
reply_toUUID v7ID ìránṣẹ́ òbí fún ìtẹ̀léra ìjíròrò
actionsarrayÀwọn bọ́tìnnì/kíbọ́ọ̀dù ìbáṣepọ̀
platform_databytesÌgbékọjá aláìfojúhàn fún àwọn ẹ̀yà pàtó pẹpẹ
timestampISO 8601Olùtẹ̀jáde ló ń ṣètò èyí

Àpẹẹrẹ ìpele méjì: Àwọn pápá àjọlò (ọ̀rọ̀, àsomọ́, reply_to, actions) ń bo 90% ìfiránṣẹ́ tí òṣìṣẹ́ bẹ̀rẹ̀. Àwọn ẹ̀yà pàtó pẹpẹ ń lọ sínú platform_data — plugin rẹ ń yí wọn padà sí ìrísí pẹpẹ àbínibí àti láti inú rẹ̀.

Àwọn Ìṣàn Ìjíròrò

A ń darí àwọn ìránṣẹ́ ìkànnì lórí ìṣàn ìjíròrò fún ìkànnì kọ̀ọ̀kan fún ìyàsọ́tọ̀:

neboai/bot/{botID}/channels/{channelType}/inbound    # messages from users → agent
neboai/bot/{botID}/channels/{channelType}/outbound   # messages from agent → channel

Àpẹẹrẹ Go — Ìkànnì 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
        }
    ]
}

Àwọn Agbára Míì

Áàpù Comm

Kéde "provides": ["comm"] àti "permissions": ["comm:*"]. Àwọn áàpù comm ń jẹ́ kí ìbánisọ̀rọ̀ ṣeé ṣe láàárín àwọn òṣìṣẹ́ AI.

PápáÀpèjúwe
fromID òṣìṣẹ́ olùfiránṣẹ́
toID òṣìṣẹ́ olùgbà
topicÀkòrí/ìkànnì ìránṣẹ́
type"message", "mention", "proposal", "command", "info", "task"
contentAra ìránṣẹ́

Àwọn ìwà pàtàkì:

  • Register ń kéde òṣìṣẹ́ AI yìí lórí nẹ́tíwọ́ọ̀kì pẹ̀lú àwọn agbára rẹ̀
  • Subscribe/Unsubscribe ń ṣàkóso ìforúkọsílẹ̀ àwọn àkòrí
  • Receive ń ṣàn àwọn ìránṣẹ́ tí ó wọlé (server-streaming, bákan náà bí àwọn ìkànnì)
  • Áàpù comm kan ṣoṣo ló lè ṣiṣẹ́ ní àkókò kan

Áàpù Gateway

Áàpù gateway ń darí àwọn ìbéèrè LLM sí àwọn àwòṣe. Kéde "provides": ["gateway"] àti "permissions": ["network:outbound", "user:token"].

GatewayRequest ní àwọn ìránṣẹ́, irinṣẹ́, ìtọ́ni ètò, iye token tí ó pọ̀ jù, temperature, àti UserContext kan (token JWT bí a bá fún un ní àṣẹ user:token).

Àwọn irú GatewayEvent:

IrúÀkóónúÀpèjúwe
"text"Apá ọ̀rọ̀Token ọ̀rọ̀ tí ń ṣàn
"tool_call"JSONÀwòṣe fẹ́ pe irinṣẹ́ kan
"thinking"Apá ọ̀rọ̀Ríronú/ìrònú jinlẹ̀ tí ó gbòòrò
"error"Ìránṣẹ́ àṣìṣeNǹkan kan ti bàjẹ́
"done"ÒfoÌṣàn ti parí

Áàpù UI

Áàpù UI ń pèsè interface ìṣètò àdáni tí ó ń ṣí nínú fèrèsé aṣàwákiri tí a kọ́ sínú Nebo. Kéde "provides": ["ui"]. Yàtọ̀ sí fọ́ọ̀mù ètò aládàáṣe (tí Nebo ń ṣe láti inú manifest settings rẹ), áàpù UI ń pèsè frontend HTML/CSS/JS kíkún tirẹ̀.

Áàpù rẹ ń jáde pẹ̀lú fódà ui/ tí ó ní àwọn ohun-ìní wẹ́ẹ̀bù aláìyípadà (HTML, CSS, JS — ní ọ̀pọ̀ ìgbà SPA pẹ̀lú index.html). Nebo ń pèsè àwọn fáìlì wọ̀nyí tààrà, ó sì ń gbé àwọn ìpè API kọjá sí áàpù rẹ nípasẹ̀ gRPC.

Ọ̀nàỌ̀nà ìṣiṣẹ́Ète
GET /api/v1/apps/{id}/ui/*Sáfà fáìlì aláìyípadàÓ ń pèsè àwọn fáìlì láti inú fódà ui/ rẹ (SPA ń padà sí index.html)
ANY /api/v1/apps/{id}/api/*gRPC proxyÓ ń gbé àwọn ìbéèrè HTTP kọjá sí UIService.HandleRequest() áàpù rẹ

SDK náà ń wé net/http.ServeMux boṣewa kan, nítorí náà o ń kọ àwọn handler HTTP Go déédéé — SDK náà ń bójú tó afárá gRPC fúnra rẹ̀.

Àpẹẹrẹ Go — UI Dashboard:

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 rẹ yóò ṣe àwọn ìpè fetch sí /api/v1/apps/com.example.dashboard/api/status, tí a ó gbé kọjá sí handler mux rẹ.

Áàpù Ètò Àkókò

Áàpù ètò àkókò ń rọ́pò olùṣètò cron tí a kọ́ sínú Nebo. Kéde "provides": ["schedule"] àti "permissions": ["schedule:create"].

Nígbà tí áàpù ètò àkókò rẹ bá bẹ̀rẹ̀, Nebo yóò darí gbogbo ìṣètò àkókò gba inú áàpù rẹ dípò ẹ̀rọ cron ìpìlẹ̀. Bí áàpù rẹ bá dàwó, Nebo yóò padà sí ẹ̀rọ tí a kọ́ sínú rẹ̀ fúnra rẹ̀.

  • Áàpù rẹ ló ni ipò ètò àkókò — Nebo kì í tọ́jú àwọn ètò àkókò sínú DB tirẹ̀ nígbà tí áàpù ètò àkókò bá ń ṣiṣẹ́
  • CRUD boṣewa: Create, Get, List, Update, Delete, Enable, Disable
  • Triggers jẹ́ RPC server-streaming — áàpù rẹ ń fi ìránṣẹ́ trigger ránṣẹ́ nígbàkígbà tí ètò àkókò kan bá ṣẹlẹ̀
  • Áàpù ètò àkókò kan ṣoṣo ló lè ṣiṣẹ́ ní àkókò kan

Àwọn Áàpù Ọ̀pọ̀ Agbára

Áàpù kan lè pèsè ọ̀pọ̀ agbára. Bí àpẹẹrẹ, áàpù dashboard tí ó ní irinṣẹ́ àti UI papọ̀:

{
    "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())

Ìdìpọ̀

Ìrísí .napp

Fún pínpín nípasẹ̀ NeboAI, di áàpù rẹ pọ̀ gẹ́gẹ́ bí fáìlì .napp (àpò tar.gz):

cd com.example.myapp/
tar -czf myapp-1.0.0.napp manifest.json binary signatures.json TOOL.md

Àwọn fáìlì tí ó pọn dandan:

FáìlìÌwọ̀n tí ó pọ̀ jùÀpèjúwe
manifest.json1 MBMetadata áàpù
binary tàbí app500 MBFáìlì aláṣẹ
signatures.json1 MBÀwọn ìfọwọ́sí Ed25519
TOOL.md1 MBÌtọ́ni irinṣẹ́ fún òṣìṣẹ́ AI

Àwọn òfin ààbò nígbà ìyọjáde:

  • Kò sí ìrìn-ọ̀nà kọjá ààlà (a kọ ../)
  • Kò sí symlink (a kọ̀ wọ́n)
  • Kò sí ọ̀nà pípé (a kọ̀ wọ́n)
  • Àwọn orúkọ fáìlì tí ó wà nínú àtòjọ ìgbàláàyè nìkan ni a gbà

Àwọn ìfọwọ́sí

NeboAI ń fọwọ́ sí àwọn áàpù pẹ̀lú Ed25519. Ìrísí 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>"
}

Ní ipò dev (tí a kò ṣètò URL NeboAI), a fo ìfìdímúlẹ̀ ìfọwọ́sí pátápátá. O kò nílò signatures.json fún ìgbéejáde orí ẹ̀rọ.

Ṣíṣe àtẹ̀jáde

Ní kété tí áàpù rẹ bá ti ń ṣiṣẹ́ lórí ẹ̀rọ rẹ, ṣe àtẹ̀jáde rẹ̀ nípasẹ̀ NeboAI fún pínpín sí gbogbo olùlò Nebo.

Ìṣètò Àkọọ́lẹ̀ Olùgbéejáde

  1. Forúkọ àkọọ́lẹ̀ NeboAI sílẹ̀ ní POST /api/v1/owners/register
  2. Wọlé láti gba token JWT: POST /api/v1/owners/login
  3. Ṣẹ̀dá àkọọ́lẹ̀ olùgbéejáde: POST /api/v1/developer/accounts

Ìlànà Ìfiránṣẹ́

draft → pending_review → [approved] → published
                       → [rejected] → draft (fix and resubmit)

Ìgbésẹ̀ 1: Ṣẹ̀dá áàpù náà

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"
  }'

Ìgbésẹ̀ 2: Gbé àwọn binary pẹpẹ sókè

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"

Gbé binary kan sókè fún pẹpẹ kọ̀ọ̀kan: darwin-arm64, darwin-amd64, linux-amd64, linux-arm64.

Ìgbésẹ̀ 3: Fi ránṣẹ́ fún àyẹ̀wò

curl -X POST https://neboai.com/api/v1/developer/apps/{id}/submit \
  -H "Authorization: Bearer $TOKEN"

Ìlànà Àyẹ̀wò

  1. Àyẹ̀wò aládàáṣe — a ń yẹ àwọn binary wò nípasẹ̀ VirusTotal
  2. Àyẹ̀wò alábòójútó — ẹgbẹ́ NeboAI ń yẹ metadata, manifest, àti àbájáde àyẹ̀wò wò
  3. Nígbà ìfọwọ́sí — NeboAI ń fọwọ́ sí áàpù náà pẹ̀lú Ed25519, ó sì ń ṣe àtẹ̀jáde rẹ̀
  4. Nígbà ìkọ̀sílẹ̀ — o ń gba ìdí, o sì lè ṣàtúnṣe kí o tún fi ránṣẹ́

Àkókò àyẹ̀wò tí a ń fojú sùn: <24 wákàtí.

Fífi Àwọn Àtúnṣe Ránṣẹ́

  1. Ṣe àtúnṣe ẹ̀dà ìṣàfilọ́lẹ̀ náà: PUT /api/v1/developer/apps/{id} pẹ̀lú ẹ̀dà tuntun
  2. Gbé àwọn binary tuntun sókè fún pẹpẹ kọ̀ọ̀kan
  3. Tún fi ránṣẹ́ fún àyẹ̀wò

Àtúnṣe kọ̀ọ̀kan ń gba inú ìlànà àyẹ̀wò kan náà. Àwọn ẹ̀dà tí ó ti kọjá ń wà síbẹ̀ títí tí a ó fi fọwọ́ sí ẹ̀dà tuntun.

Metadata Ilé Ìtajà

PápáÀpèjúwe
categorybí àpẹẹrẹ, productivity, communication, developer-tools
iconURL àmì áàpù
visibilitypublic tàbí private
descriptionÓ lè gùn jù tàbí ní ọ̀rọ̀ púpọ̀ ju àpèjúwe manifest lọ

Ìlànà Iṣẹ́ Dev

Ìgbéejáde Orí Ẹ̀rọ

Kò nílò ìdìpọ̀ fún ìgbéejáde orí ẹ̀rọ:

  1. Ṣẹ̀dá directory ìṣàfilọ́lẹ̀ rẹ:
    mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp
  2. Kọ manifest.json àti kóòdù rẹ
  3. Kọ́ binary rẹ:
    go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary .
  4. Nebo yóò rí fódà tuntun náà fúnra rẹ̀ (tàbí tún Nebo bẹ̀rẹ̀)
  5. Lẹ́yìn àwọn ìyípadà kóòdù, tún binary náà kọ́ — olùṣọ́ fáìlì yóò tún áàpù náà bẹ̀rẹ̀

Wíwo Àwọn Àkọsílẹ̀

A ń gba stdout/stderr áàpù sínú àwọn fáìlì àkọsílẹ̀ fún áàpù kọ̀ọ̀kan:

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

Dátà Tí Ó Wà Pẹ́

Lo fódà data/ (tí ó tún wà gẹ́gẹ́ bí env var NEBO_APP_DATA) fún àwọn fáìlì èyíkéyìí tí áàpù rẹ nílò láti pa mọ́. Fódà yìí ń là á já nígbà àtúnṣe áàpù àti ìyàsọ́tọ̀.

Àwọn Ìmọ̀ràn Ìtúnṣe Àṣìṣe

  • Bí áàpù rẹ kò bá bẹ̀rẹ̀, ṣàyẹ̀wò logs/stderr.log fún àwọn àṣìṣe
  • Rí i dájú pé binary náà ṣeé ṣiṣẹ́ (chmod +x binary)
  • Rí i dájú pé ò ń gbọ́ lórí ọ̀nà Unix socket láti NEBO_APP_SOCK
  • Socket náà gbọ́dọ̀ ṣetán láàárín ìṣẹ́jú-àáyá 10 lẹ́yìn ìṣísílẹ̀
  • Lo NEBO_APP_DATA fún ibi ìpamọ́, kì í ṣe àwọn ọ̀nà tí a kọ sínú kóòdù
  • Kọ sí stderr fún àkọsílẹ̀ ìtúnṣe àṣìṣe (tí a gbà sínú logs/stderr.log)

Ìfìdímúlẹ̀

# 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

Yíyọ kúrò lórí ẹ̀rọ

nebo apps uninstall com.example.myapp

Àwọn ọgbọ́n

Kí Ni Àwọn Ọgbọ́n Jẹ́

Àwọn ọgbọ́n jẹ́ àkójọ ìtọ́ni tí ó ń ṣe àpẹẹrẹ bí Nebo ṣe ń hùwà nígbà ìjíròrò. Nígbà tí ọgbọ́n kan bá ń ṣiṣẹ́, a ń fi àkóónú rẹ̀ sínú ìtọ́ni ètò tààrà — tí ó ń darí ohùn òṣìṣẹ́ AI, ọ̀nà iṣẹ́ rẹ̀, ìmọ̀ pàtàkì rẹ̀, àti lílo irinṣẹ́ fún ìgbà yẹn.

Àwọn ọgbọ́n kì í ṣe kóòdù. Ìwé markdown ni wọ́n pẹ̀lú metadata YAML. Kò sí ṣíṣàkójọ, kò sí binary, kò sí gRPC. Ọgbọ́n kan jẹ́ fáìlì SKILL.md nínú fódà kan. Ìyẹn ni.

Àwọn ọgbọ́n jẹ́ ti àyíká, wọn kò sì pẹ́. Wọ́n ń ṣiṣẹ́ nígbà tí wọ́n bá yẹ (nípasẹ̀ bíbá trigger mu tàbí gbígbé wọlé fúnra ẹni), wọ́n ń wà fún ìyípo díẹ̀, wọ́n sì ń parí nígbà tí a kò bá nílò wọn mọ́. Èyí ń jẹ́ kí àyíká òṣìṣẹ́ AI fúyẹ́ — ìtọ́sọ́nà tí ó ṣe pàtàkì báyìí nìkan ló wà nínú ìtọ́ni.

Àwọn ọgbọ́n ń ṣàfikún àwọn áàpù. Àwọn áàpù ń pèsè agbára tí ó ṣeé ṣiṣẹ́ (àwọn irinṣẹ́, ìkànnì, gateway). Àwọn ọgbọ́n ń pèsè ìtọ́sọ́nà ìṣètò — bí a ṣe ń lo àwọn irinṣẹ́ wọ̀nyẹn dáadáa. Áàpù kàlẹ́ńdà ń fún Nebo ní agbára láti kà àti kọ àwọn ìṣẹ̀lẹ̀. Ọgbọ́n "ìmúrasílẹ̀ fún ìpàdé" ń sọ fún Nebo bí ó ṣe lè múra sílẹ̀ fún àwọn ìpàdé nípa lílo áàpù kàlẹ́ńdà náà, ímeèlì, àti ìwádìí wẹ́ẹ̀bù papọ̀.

Àwọn Ọgbọ́n àti Àwọn Áàpù

Àwọn ọgbọ́nÀwọn áàpù
ÌrísíMarkdown (SKILL.md)Binary tí a ṣàkójọ (.napp)
Ìgbà ìṣiṣẹ́A fi sínú ìtọ́ni ètòÌlànà inú sandbox lórí gRPC
Ohun tí ó ń pèsèÌtọ́sọ́nà ìwà, ọ̀nà iṣẹ́Àwọn irinṣẹ́, ìkànnì, pánẹ́ẹ̀lì UI
Ìgbà ayéFún ìgbà ìjíròrò kan, ó ń parí gẹ́gẹ́ bí TTLÓ ń ṣiṣẹ́ nígbà gbogbo
Ṣíṣẹ̀dáKọ fáìlì markdown kanKọ ọ́, ṣàkójọ rẹ̀, fọwọ́ sí i, dì í pọ̀
ÀàbòKò nílò àṣẹ kankanSandbox tí ó kọ̀ ní ìpìlẹ̀

Ìbẹ̀rẹ̀ kíákíá

Ṣẹ̀dá fódà kan nínú fódà ọgbọ́n Nebo rẹ pẹ̀lú fáìlì SKILL.md:

~/Library/Application Support/Nebo/skills/   # macOS
~/.config/nebo/skills/                        # Linux
%AppData%\Nebo\skills\                        # Windows
mkdir -p ~/.config/nebo/skills/my-skill

Kọ SKILL.md kan:

---
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 ń ṣọ́ fódà ọgbọ́n pẹ̀lú fsnotify. Ọgbọ́n rẹ wà lẹ́sẹ̀kẹsẹ̀ — kò nílò àtúnbẹ̀rẹ̀. Sọ nǹkan kan tí ó bá trigger mu, yóò sì bẹ̀rẹ̀ iṣẹ́ fúnra rẹ̀.

Tàbí béèrè lọ́wọ́ Nebo tààrà: "Ṣẹ̀dá ọgbọ́n kan fún kíkọ àwọn àpilẹ̀kọ búlọ́ọ̀gù" — Nebo yóò kọ fáìlì SKILL.md náà fún ọ.

Ìrísí SKILL.md

Gbogbo ọgbọ́n jẹ́ fáìlì SKILL.md kan ṣoṣo tí ó ní apá méjì: frontmatter YAML láàárín àwọn àmì ---, àti ara markdown (àwọn ìtọ́ni gidi tí a ń fi sínú ìtọ́ni ètò).

PápáÓ pọn dandanÌpìlẹ̀Àpèjúwe
nameBẹ́ẹ̀ni—Ìdámọ̀ àrà ọ̀tọ̀ (ó ń di slug)
descriptionBẹ́ẹ̀ni—Àpèjúwe ìlà kan tí ó ń hàn nínú àtòjọ ọgbọ́n
versionRárá"1.0.0"Semver fún títọpa àwọn àtúnṣe
authorRárá—Olùkọ̀wé ọgbọ́n
priorityRárá0Tí ó ga jù = a kọ́kọ́ bá a mu (100+ fún àwọn ìrọ́pò pàtàkì)
max_turnsRárá4Ìyípo àìṣiṣẹ́ kí ó tó parí fúnra rẹ̀
triggersRárá[]Àwọn gbólóhùn tí ó ń mú ọgbọ́n yìí ṣiṣẹ́ fúnra rẹ̀ (ìbámu apá ọ̀rọ̀ tí kò ka lẹ́tà ńlá tàbí kékeré sí)
toolsRárá[]Àwọn irinṣẹ́ tí ọgbọ́n yìí ń retí láti lò (fún ìsọfúnni)
dependenciesRárá[]Àwọn ọgbọ́n míì tí a gbọ́dọ̀ fi sórí ẹ̀rọ
tagsRárá[]Fún pínpín sí ẹ̀ka àti ṣíṣàwárí
platformRárá[]Àwọn pẹpẹ tí a ṣe àtìlẹ́yìn fún: macos, linux, windows (òfo = gbogbo rẹ̀)

Bí Àwọn Ọgbọ́n Ṣe Ń Bẹ̀rẹ̀ Iṣẹ́

Àwọn ọgbọ́n ń tẹ̀lé àpẹẹrẹ ìmúṣiṣẹ́ onípele méjì: ìtọ́kasí, lẹ́yìn náà pípè.

Ìpele 1: Bíbá Trigger Mu — Ní gbogbo ìgbà tí olùlò bá fi ìránṣẹ́ ránṣẹ́, Nebo ń yẹ gbogbo ọgbọ́n tí a forúkọ sílẹ̀ wò fún ìbámu trigger. Àwọn ọgbọ́n tí ó bá a mu ń hàn gẹ́gẹ́ bí ìtọ́kasí nínú ìtọ́ni ètò. Òṣìṣẹ́ AI ń rí ìtọ́kasí náà, ó sì ń pinnu bóyá yóò pe ọgbọ́n náà.

Ìpele 2: Pípè — Òṣìṣẹ́ AI ń pe ọgbọ́n kan nípa pípe:

skill(name: "code-review")

Èyí ń dá gbogbo àwòṣe SKILL.md padà gẹ́gẹ́ bí àbájáde irinṣẹ́, ó ń ṣe àkọsílẹ̀ pípè náà, ó sì ń tún fi àwòṣe náà sínú ìtọ́ni ètò ní àwọn ìyípo tí ó tẹ̀lé e.

TTL àti Ìparí:

  • Àwọn ọgbọ́n tí a bá mu fúnra wọn: ìyípo àìṣiṣẹ́ 4 (a lè ṣàtúnṣe rẹ̀ nípasẹ̀ max_turns)
  • Àwọn ọgbọ́n tí a gbé wọlé fúnra ẹni: ìyípo àìṣiṣẹ́ 6
  • Pípè lẹ́ẹ̀kan sí i ń tún aago náà bẹ̀rẹ̀
  • Òdiwọ̀n líle: ọgbọ́n 4 tí ń ṣiṣẹ́ ní pọ̀ jù fún ìgbà ìjíròrò kan
  • Ìnáwó token: àkóónú àpapọ̀ àwọn ọgbọ́n tí ń ṣiṣẹ́ kò lè ju àmì 16,000 lọ

Ṣíṣàkóso Àwọn Ọgbọ́n

Òṣìṣẹ́ AI lè ṣàkóso àwọn ọgbọ́n nípasẹ̀ irinṣẹ́ skill:

ActionÀpèjúweÀpẹẹrẹ
catalogṢe àtòjọ gbogbo ọgbọ́n tí ó wàskill(action: "catalog")
loadMú un ṣiṣẹ́ fún ìgbà ìjíròrò yìískill(name: "code-review", action: "load")
unloadDá ọgbọ́n kan dúróskill(name: "code-review", action: "unload")
createṢẹ̀dá ọgbọ́n tuntun sórí diskskill(action: "create", content: "...")
updateṢe àtúnṣe ọgbọ́n tí ó wà tẹ́lẹ̀skill(name: "my-skill", action: "update", content: "...")
deletePa ọgbọ́n kan rẹ́ kúrò lórí diskskill(name: "my-skill", action: "delete")

Kíkọ Àwọn Ọgbọ́n Rere

Àwòṣe ọgbọ́n rere ní:

  1. Àkọlé tí ó ṣe kedere — ó ń sọ fún òṣìṣẹ́ AI ipò tí ó wà
  2. Àwọn ìlànà pàtàkì — àwọn òfin ìwà tí kò ṣeé dúnàádúrà
  3. Ọ̀nà iṣẹ́ — ọ̀nà ìgbésẹ̀-ìgbésẹ̀ fún àwọn ipò tí ó wọ́pọ̀
  4. Àwọn àpẹẹrẹ — àpẹẹrẹ gidi láti ìránṣẹ́ olùlò sí ìdáhùn
  5. Àwọn àpẹẹrẹ òdì — ohun tí a KÒ gbọ́dọ̀ ṣe (àwọn àwòṣe ń kọ́ ẹ̀kọ́ dáadáa láti inú àpẹẹrẹ òdì)

Ìmọ̀ràn: Ọgbọ́n kọ̀ọ̀kan yẹ kí ó ṣe ohun kan dáadáa. Má ṣe ṣẹ̀dá ọgbọ́n "ìṣètò kọ̀ǹpútà gbogbogbòò" — ṣẹ̀dá code-review, debugging, api-design gẹ́gẹ́ bí ọgbọ́n ọ̀tọ̀ọ̀tọ̀. Òṣìṣẹ́ AI lè ní ọ̀pọ̀ tí ń ṣiṣẹ́ lẹ́ẹ̀kan náà.

Àwọn Ọgbọ́n Tí Ó Wà Pẹ̀lú Rẹ̀

Nebo ń jáde pẹ̀lú àwọn ọgbọ́n tí ó bo àwọn ọ̀nà ìlò tí ó wọ́pọ̀:

Ọgbọ́nIpò àkọ́kọ́Àpèjúwe
onboarding100Kíkí olùlò tuntun àti gbígba ìsọfúnni profaili
best-friend50Ọgbọ́n ìwà — ọ̀rọ̀ tí ó rọrùn, olóòótọ́, ojúlówó
debugging25Ọ̀nà ìtúnṣe àṣìṣe tí ó létòlétò
api-design15Àwọn ìṣe tí ó dára jù fún àpẹẹrẹ RESTful API
code-review10Àyẹ̀wò kóòdù tí ó létòlétò pẹ̀lú àwọn ìpele bí ó ṣe le tó
database-expert10Àpẹẹrẹ ibi ìpamọ́ dátà, àwọn query, ìmúdára
git-workflow10Ẹ̀ka Git, àwọn commit, àwọn ìlànà iṣẹ́ PR
security-audit10Àtúpalẹ̀ ààbò àti ṣíṣàwárí àìlágbára

Àwọn wọ̀nyí jẹ́ ìpìlẹ̀ tí ó wúlò àti àpẹẹrẹ ìtọ́kasí fún ṣíṣẹ̀dá àwọn ọgbọ́n tìrẹ.

Ìtọ́kasí

Àwọn Fáìlì Proto

Àwọn fáìlì proto wà nínú proto/apps/v0/. Àwọn SDK ń jáde pẹ̀lú kóòdù tí a ti ṣẹ̀dá tẹ́lẹ̀, nítorí náà o kò nílò protoc fún ìgbéejáde déédéé.

FáìlìIṣẹ́Àwọn RPC pàtàkì
v0/common.proto(àwọn ìránṣẹ́ nìkan)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

Gbogbo iṣẹ́ ní àwọn RPC HealthCheck àti Configure. SDK náà ń bójú tó méjèèjì fúnra rẹ̀.

Àwọn Irú Proto Ìkànnì

Irú Ìránṣẹ́Àpèjúwe
ChannelSendRequestÀpò-ìwé ìránṣẹ́ tí ó jáde pẹ̀lú message_id, channelId, sender, text, attachments, reply_to, actions, platform_data
ChannelSendResponseID ìránṣẹ́ pẹpẹ fún ìtẹ̀léra ìjíròrò
InboundMessageÀpò-ìwé ìránṣẹ́ tí ó wọlé pẹ̀lú gbogbo àwọn pápá àjọlò + àkókò
MessageSenderÌdánimọ̀ bot (name, role, botId) — alágbàtà ló ń fi kún un
AttachmentÀsomọ́ fáìlì/àwòrán/ìró (type, url, filename, size)
MessageActionAction bọ́tìnnì/kíbọ́ọ̀dù ìbáṣepọ̀ (label, callback_id)

Ìdánimọ̀ Bot àti Àwọn Ipa

Àwọn bot Nebo ní àpẹẹrẹ ìdánimọ̀ onígun mẹ́ta:

  • creature — Ohun tí bot náà jẹ́ (àwòkọ́ṣe): "Onímọ̀ràn tí ọpọlọ rẹ̀ yá", "Olùwádìí tí ó fara balẹ̀"
  • role — Bí ó ṣe jọmọ́ olùlò (ìbáṣepọ̀): "Ọ̀rẹ́", "COO", "Olùtọ́nisọ́nà"
  • vibe — Agbára rẹ̀ (ọ̀nà ìbánisọ̀rọ̀): "Ó jẹ́ jẹ́jẹ́ ṣùgbọ́n ó ní èrò tirẹ̀", "Ó lọ́yàyà, ó sì ń fúnni ní ìṣírí"

Nígbà tí plugin ìkànnì rẹ bá gba ìránṣẹ́ tí ó jáde, pápá sender ní name àti role bot náà. Lo èyí láti ṣe orúkọ ìfihàn fún pẹpẹ rẹ. Ipa náà kì í ṣe orúkọ ipò iṣẹ́ — ó jẹ́ àpèjúwe ìbáṣepọ̀. "Ọ̀rẹ́", "Ọmọkùnrin", àti "Olùtọ́nisọ́nà" jẹ́ ipa tí ó tọ́ lẹ́gbẹ̀ẹ́ "COO" àti "DevLead".