Yleiskatsaus
Mikä Nebo on
Nebo on henkilökohtainen työpöydän tekoälyavustaja — aina käynnissä oleva tekoälytyöntekijä, joka hoitaa digitaalista elämääsi. Ajattele Neboa samoin kuin älypuhelinta: tehokas alusta, josta tulee mullistava sovellustensa ansiosta.
Sellaisenaan Nebo on kyvykäs tekoälytyöntekijä, jolla on muisti, ajastus, verkkoselaus, tiedostojen hallinta ja komentotulkin käyttö. Todellinen avain ovat kuitenkin sovellukset. Aivan kuten älypuhelimen voima tulee sen sovellusekosysteemistä, Nebon voima tulee sovelluksista, jotka laajentavat sen kykyjä.
Mitä sovellukset ovat
Nebo-sovellukset ovat itsenäisiä, valmiiksi käännettyjä ja uskomattoman toimivia kokonaisuuksia. Jokainen sovellus antaa Nebolle uuden supervoiman — kalenterin hallinta, sähköpostien lajittelu, projektien seuranta, kodin automaatio, talousanalyysi — mitä tahansa kehittäjä keksii.
Sovellukset tarjoavat uskomatonta tehoa erittäin turvallisella tavalla. Jokainen sovellus toimii hiekkalaatikossa, jossa kaikki on oletuksena kielletty. Se pääsee käsiksi vain siihen, minkä sen manifesti ilmoittaa ja käyttäjä hyväksyy.
Käyttöliittymä on 100-prosenttisesti keskusteleva. Käyttäjät eivät käytä sovelluksia erillisten näkymien tai koontinäyttöjen kautta. He puhuvat Nebolle, ja Nebo käyttää sovelluksen työkaluja asioiden hoitamiseen. ”Mitä kalenterissani on huomenna?” — Nebo kutsuu kalenterisovellusta. ”Luo tapaaminen Sarahin kanssa kello 15” — Nebo kutsuu kalenterisovellusta. Käyttäjä ei koskaan poistu keskustelusta.
Sovellukset voivat halutessaan tarjota asetusnäkymän — määrityspaneelin, joka avautuu Nebon sisäänrakennettuun selainikkunaan. Siellä käyttäjät syöttävät API-avaimia, kytkevät ominaisuuksia päälle ja pois ja määrittävät sovelluksen. Asetusnäkymää ohjaa manifestin settings-taulukko (Nebo piirtää lomakkeen automaattisesti), tai sovellus voi tarjota oman täysin mukautetun käyttöliittymän ui-kyvyn kautta.
Sovellukset korvaavat ja laajentavat Nebon sisäänrakennettuja kykyjä. Nebon mukana tulee perustason alustatyökaluja (paikallisen kalenterin käyttö, kuvakaappaukset jne.). Kun asennat kalenterisovelluksen, se korvaa sisäänrakennetun kalenterityökalun ja muodostaa sen ylijoukon — paikallinen + pilvi + yhdistäminen + saatavuuden tarkistus.
Vain käännetyt -käytäntö
Nebo noudattaa tiukkaa käytäntöä, jonka mukaan vain käännetyt binäärit sallitaan. Kaikkien sovellusten on oltava natiivisti käännettyjä suoritettavia tiedostoja.
| Tila | Kielet |
|---|---|
| Tuettu | Go (suositeltu), Rust, C/C++, Zig |
| Hylätty | Python, Node.js, Ruby, Java, .NET, komentotulkin skriptit |
Perustelut:
- Tekoälyn itsemuokkauksen estäminen — Tekoälytyöntekijä, jolla on komentotulkin käyttöoikeus, voisi muuttaa tulkattavan skriptin toimintaa ajon aikana. Käännetyt binäärit ovat muuttumattomia allekirjoittamisen jälkeen.
- Allekirjoituksen eheys — Ed25519-allekirjoitukset kattavat binäärin raakatavut. Allekirjoitettua binääriä ei voi muokata mitätöimättä allekirjoitusta.
- Hiekkalaatikon valvonta — Binäärimuodon validointi (ELF/Mach-O/PE-tunnistetavut) on nopea ja luotettava portti.
Pika-aloitus
Asenna SDK
Viralliset SDK:t hoitavat kaiken gRPC-palvelimen käyttöönoton, signaalien käsittelyn ja protokollasiltauksen. Sinä vain toteutat käsittelijärajapinnat.
Go (suositeltu):
go get github.com/neboloop/nebo-sdk-go Rust (tulossa pian):
# Coming soon
[dependencies]
nebo-sdk = "0.1" C/C++ (tulossa pian):
# Coming soon — Add as a CMake subdirectory or copy headers from sdk/c/include/ Sovelluksen hakemistorakenne
Sovellukset sijaitsevat Nebon datahakemiston alihakemistossa apps/:
~/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) Minimisovelluksen tarkistuslista
- Luo
manifest.json, jossa onid,name,version,provides - Kirjoita
TOOL.md, joka kuvaa, miten tekoälytyöntekijän tulee käyttää työkaluasi - Asenna SDK (
go get github.com/neboloop/nebo-sdk-go) - Toteuta kykysi käsittelijärajapinta (
ToolHandler,ChannelHandlerjne.) - Rekisteröi käsittelijä ja kutsu
app.Run() - Rakenna natiivi binääri (
go build -o binary .) - Sijoita binääri + manifest.json + TOOL.md hakemistoon
apps/<your-app-id>/ - Nebo löytää ja käynnistää sen automaattisesti
Määritykset
manifest.json
Jokainen sovellus vaatii tiedoston 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
}
]
} Pakolliset kentät:
| Kenttä | Kuvaus |
|---|---|
id | Käänteisen verkkotunnuksen muotoinen tunniste (esim. com.mycompany.myapp) |
name | Ihmisluettava nimi |
version | Semver-merkkijono |
provides | Vähintään yksi kyky (katso alla) |
Valinnaiset kentät:
| Kenttä | Oletus | Kuvaus |
|---|---|---|
runtime | "local" | "local" tai "remote" |
protocol | "grpc" | Vain "grpc" on tuettu |
permissions | [] | Mihin sovellus tarvitsee käyttöoikeuden |
description | "" | Näytetään käyttöliittymässä |
settings | [] | Määritettävät asetukset (näytetään asetusnäkymässä) |
oauth | [] | OAuth-palveluntarjoajan vaatimukset (katso OAuth-osio alla) |
Kyvyt
Ilmoita, mitä sovelluksesi tarjoaa:
| Kyky | gRPC-palvelu | Kuvaus |
|---|---|---|
gateway | GatewayService | LLM-mallien reititys |
tool:<name> | ToolService | Nimetty työkalu tekoälytyöntekijälle |
channel:<name> | ChannelService | Viestikanava |
comm | CommService | Viestintä tekoälytyöntekijöiden välillä |
ui | UIService | Mukautettu käyttöliittymä HTTP-välityspalvelimella |
schedule | ScheduleService | Mukautettu ajastus |
vision | ToolService | Kuvien käsittely |
browser | ToolService | Selainautomaatio |
Sovellus voi tarjota useita kykyjä. Sovellus voi esimerkiksi tarjota sekä työkalun että käyttöliittymäpaneelin.
Luvat
Luvat määräävät, mihin sovellus pääsee käsiksi. Oletuksena kielletty — jos lupaa ei ole ilmoitettu, sovellus ei voi käyttää sitä.
| Etuliite | Esimerkit | Kuvaus |
|---|---|---|
network: | network:outbound, network:* | Verkkoyhteys |
filesystem: | filesystem:read, filesystem:write | Tiedostojärjestelmän käyttö |
memory: | memory:read, memory:write | Tekoälytyöntekijän muistin käyttö |
session: | session:read | Keskusteluistunnot |
tool: | tool:shell, tool:file | Muiden työkalujen käyttö |
shell: | shell:exec | Komentotulkin komentojen suoritus |
channel: | channel:send, channel:* | Kanavatoiminnot |
comm: | comm:send, comm:* | Viestintä tekoälytyöntekijöiden välillä |
model: | model:chat | Tekoälymallien käyttö |
user: | user:token | Käyttäjän JWT:n vastaanotto pyynnöissä |
schedule: | schedule:create | Cron-töiden hallinta |
database: | database:query | Tietokannan käyttö |
storage: | storage:read, storage:write | Pysyvä tallennus |
context: | context:read | Tekoälytyöntekijän kontekstin käyttö |
subagent: | subagent:spawn | Ala-agenttien toiminnot |
lane: | lane:enqueue | Kaistatoiminnot |
notification: | notification:send | Push-ilmoitukset |
embedding: | embedding:search | Vektoriupotusten käyttö |
skill: | skill:invoke | Taitojen kutsuminen |
advisor: | advisor:consult | Neuvonantajajärjestelmän käyttö |
mcp: | mcp:connect | MCP-palvelimen käyttö |
voice: | voice:record | Äänen/audion käyttö |
browser: | browser:navigate | Selainautomaatio |
oauth: | oauth:google, oauth:* | OAuth-tunnusten käyttö |
settings: | settings:read | Asetusten käyttö |
capability: | capability:register | Kykyjen rekisteröinti |
Jokerimerkkiluvat ovat tuettuja: network:* vastaa mitä tahansa network:-lupatarkistusta.
Asetukset
Asetukset näkyvät Nebon käyttöliittymässä sovelluksen asetuspaneelissa. Nebo tallentaa ne tietokantaan ja lähettää ne sovelluksellesi Configure-RPC:n kautta, kun ne muuttuvat.
Asetusskeemasi sisältyy NeboAI-sovelluskaupan listaukseen. Sovellukset, joiden pakollisia asetuksia ei ole määritetty, näyttävät käyttöliittymässä ”Needs Setup” -merkin.
| Tyyppi | Kuvaus |
|---|---|
text | Yksirivinen tekstikenttä |
password | Peitetty tekstikenttä |
toggle | Totuusarvoinen päälle/pois-kytkin |
select | Pudotusvalikko ennalta määritetyillä vaihtoehdoilla |
number | Numerokenttä |
url | URL-kenttä validoinnilla |
{
"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-vaatimukset
Sovellukset voivat ilmoittaa OAuth-palveluntarjoajan vaatimuksia. Nebon OAuth-välittäjä hoitaa koko prosessin — sovellukset saavat tunnukset automaattisesti Configure-RPC:n kautta.
{
"oauth": [
{
"provider": "google",
"scopes": ["https://www.googleapis.com/auth/calendar"]
}
]
} | Kenttä | Kuvaus |
|---|---|
provider | OAuth-palveluntarjoaja: "google", "microsoft", "github" |
scopes | Taulukko sovelluksen tarvitsemista OAuth-laajuuksista |
Kun käyttäjä asentaa sovelluksen, Nebo pyytää häntä valtuuttamaan vaaditut OAuth-laajuudet. Sovellus saa päivitetyt tunnukset Configure-RPC:n kautta ilman, että sen tarvitsee itse hoitaa OAuth-prosessia.
Ympäristömuuttujat
Sovellusprosessisi saa puhdistetun ympäristön. Kaikki salaisuudet poistetaan. Saat:
| Muuttuja | Arvo |
|---|---|
NEBO_APP_DIR | Sovelluksen asennushakemisto |
NEBO_APP_SOCK | Luotavan Unix-socketin polku |
NEBO_APP_ID | Sovelluksen ID manifestista |
NEBO_APP_NAME | Sovelluksen nimi manifestista |
NEBO_APP_VERSION | Sovelluksen versio manifestista |
NEBO_APP_DATA | Polku sovelluksen data/-hakemistoon |
PATH | Järjestelmän PATH (välitetään sellaisenaan) |
HOME | Käyttäjän kotihakemisto (välitetään sellaisenaan) |
TMPDIR | Väliaikaishakemisto (välitetään sellaisenaan) |
Tärkeää: Binäärisi on luotava gRPC-palvelin, joka kuuntelee Unix-socketia polussa NEBO_APP_SOCK. Nebo odottaa tämän socketin ilmestymistä enintään 10 sekuntia.
Sovelluksen käynnistysjärjestys
- Nebo lukee tiedoston
manifest.jsonja validoi sen - Etsii sovellushakemistosta suoritettavan tiedoston
binarytaiapp - Tarkistaa
.quarantined-merkinnän (karanteeniin asetettuja sovelluksia ei käynnistetä) - Mitätöintitarkistus (vain NeboAI:n jakelemat sovellukset)
- Allekirjoituksen vahvistus (vain NeboAI:n jakelemat sovellukset, ohitetaan kehitystilassa)
- Binäärin validointi (hylkää symboliset linkit, skriptit, ei-suoritettavat ja liian suuret tiedostot)
- Siivoaa edellisen ajon vanhentuneen socketin
- Luo
data/-hakemiston hiekkalaatikoitua tallennusta varten - Määrittää sovelluskohtaiset lokitiedostot (
logs/stdout.log,logs/stderr.log) - Käynnistää binäärin puhdistetulla ympäristöllä ja prosessiryhmän eristyksellä
- Odottaa Unix-socketin ilmestymistä (eksponentiaalinen viive, enintään 10 sekuntia)
- Yhdistää gRPC:llä Unix-socketin kautta
- Luo kykykohtaiset gRPC-asiakkaat
provides-kentän perusteella - Suorittaa kuntotarkistuksen
- Rekisteröi kyvyt tekoälytyöntekijälle (työkalut, yhdyskäytävä, viestintä jne.)
Työkalusovellukset
Ilmoita manifestissasi "provides": ["tool:my_tool_name"].
STRAP-malli
Kaikkien Nebon työkalusovellusten on käytettävä STRAP-mallia (Single Tool Resource Action Pattern) skeemassaan ja suorituksen reitityksessä. Tämä on sama malli, jolla Nebo sisäisesti yhdistää yli 35 yksittäistä työkalua 4 aluekohtaiseksi työkaluksi — mikä vähentää LLM:n kontekstikuormaa noin 80 %.
Perusajatus: Sen sijaan, että rekisteröisit useita työkaluja (get_events, check_availability, suggest_slots), rekisteröi YKSI työkalu, jossa on action-kenttä (ja valinnaisesti resource-kenttä), jotka reitittävät oikealle käsittelijälle.
Yhden resurssin esimerkki (kalenteri):
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") Usean resurssin esimerkki (projektinhallinta):
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") Skeemasäännöt:
- Sisällytä aina
action-kenttä pakollisena merkkijonoenumina - Lisää
resource-kenttä (pakollinen merkkijonoenum) vain, jos työkalusi hallitsee useita erillisiä resurssityyppejä - Kaikki muut kentät ovat toimintokohtaisia parametreja
action-enumin kuvauksessa tulee luetella kaikki käytettävissä olevat toiminnot
Miksi STRAP on tärkeä:
- LLM:t oppivat
action-reitityksen mallin kerran ja yleistävät sen kaikkiin toimintoihin - Työkalumääritykset vievät noin 6 % kontekstista — STRAP leikkaa sitä 80 %
- Uudet toiminnot ovat vain enum-lisäyksiä, eivät uusia työkalurekisteröintejä
- Toimii samalla tavalla sekä isännöidyillä että paikallisilla malleilla
Go-esimerkki — laskintyökalu
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": []
} Rakenna ja asenna:
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-esimerkki
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-esimerkki
#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;
} Kanavasovellukset
Ilmoita "provides": ["channel:my_channel"] ja "permissions": ["channel:send"].
Kanavasovellukset yhdistävät ulkoiset viestialustat (Telegram, Discord, Slack jne.) Nebon tekoälytyöntekijään. Kun käyttäjä lähettää viestin ulkoisella alustalla, sovelluksesi suoratoistaa sen Nebolle Receive-kutsun kautta. Kun tekoälytyöntekijä haluaa vastata, Nebo kutsuu sovelluksesi Send-metodia.
Näin se toimii
- Nebo kutsuu
ID()-metodia saadakseen kanavasi yksilöllisen tunnisteen - Nebo kutsuu
Connect()-metodia sovelluksesi asetuksista saaduilla määrityksillä - Nebo avaa
Receive()-virran — sovelluksesi lähettää saapuvat viestit aina, kun käyttäjä lähettää botille viestin - Saapuvat viestit reititetään tekoälytyöntekijän pääkeskustelukaistalle
- Kun tekoälytyöntekijä haluaa lähettää viestin, Nebo kutsuu
Send()-metodia v1-viestikuorella - Sammutettaessa Nebo kutsuu
Disconnect()-metodia
v1-viestikuori
Kaikki kanavaviestit — saapuvat ja lähtevät — käyttävät yhteistä viestikuorta:
{
"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"
} | Kenttä | Tyyppi | Kuvaus |
|---|---|---|
message_id | UUID v7 | Aikajärjestetty yksilöllinen ID |
channel_id | {type}:{platform_id} | Reititettävä kanavatunniste |
sender | object | Botin identiteetti — nimi, rooli, botId |
text | string | Viestin sisältö |
attachments | array | Tiedostot, kuvat, ääni |
reply_to | UUID v7 | Ylätason viestin ID ketjutusta varten |
actions | array | Interaktiiviset painikkeet/näppäimistöt |
platform_data | bytes | Läpinäkymätön läpivienti alustakohtaisille ominaisuuksille |
timestamp | ISO 8601 | Julkaisija asettaa tämän |
Kaksikerroksinen rakenne: Yhteiset kentät (text, attachments, reply_to, actions) kattavat 90 % työntekijän aloittamasta viestinnästä. Alustakohtaiset ominaisuudet menevät kenttään platform_data — laajennuksesi muuntaa ne alustan omaan muotoon ja takaisin.
Keskusteluvirrat
Kanavaviestit reititetään eristyksen vuoksi kanavakohtaisia keskusteluvirtoja pitkin:
neboai/bot/{botID}/channels/{channelType}/inbound # messages from users → agent
neboai/bot/{botID}/channels/{channelType}/outbound # messages from agent → channel Go-esimerkki — Telegram-kanava
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
}
]
} Lisää kykyjä
Comm-sovellus
Ilmoita "provides": ["comm"] ja "permissions": ["comm:*"]. Comm-sovellukset mahdollistavat viestinnän tekoälytyöntekijöiden välillä.
| Kenttä | Kuvaus |
|---|---|
from | Lähettäjätyöntekijän ID |
to | Vastaanottajatyöntekijän ID |
topic | Viestin aihe/kanava |
type | "message", "mention", "proposal", "command", "info", "task" |
content | Viestin sisältö |
Keskeiset toiminnot:
Registerilmoittaa tämän tekoälytyöntekijän verkkoon kykyineenSubscribe/Unsubscribehallitsevat aihetilauksiaReceivesuoratoistaa saapuvat viestit (palvelinpuolen suoratoisto, kuten kanavissa)- Vain yksi comm-sovellus voi olla aktiivisena kerrallaan
Yhdyskäytäväsovellus
Yhdyskäytäväsovellus reitittää LLM-pyynnöt malleille. Ilmoita "provides": ["gateway"] ja "permissions": ["network:outbound", "user:token"].
GatewayRequest sisältää viestit, työkalut, järjestelmäkehotteen, tokenien enimmäismäärän, lämpötilan ja UserContext-kentän (JWT-tunnus, jos user:token-lupa on myönnetty).
GatewayEvent-tyypit:
| Tyyppi | Sisältö | Kuvaus |
|---|---|---|
"text" | Tekstipala | Suoratoistettava tekstitoken |
"tool_call" | JSON | Malli haluaa kutsua työkalua |
"thinking" | Tekstipala | Laajennettu ajattelu/päättely |
"error" | Virheilmoitus | Jokin meni pieleen |
"done" | Tyhjä | Virta on valmis |
UI-sovellus
UI-sovellus tarjoaa mukautetun määrityskäyttöliittymän, joka avautuu Nebon sisäänrakennettuun selainikkunaan. Ilmoita "provides": ["ui"]. Toisin kuin automaattinen asetuslomake (jonka Nebo piirtää settings-manifestistasi), UI-sovellus tarjoaa oman täyden HTML/CSS/JS-käyttöliittymänsä.
Sovelluksesi mukana toimitetaan ui/-hakemisto, joka sisältää staattiset verkkoresurssit (HTML, CSS, JS — tyypillisesti SPA, jossa on index.html). Nebo tarjoilee nämä tiedostot suoraan ja välittää API-kutsut sovelluksellesi gRPC:n kautta.
| Polku | Mekanismi | Tarkoitus |
|---|---|---|
GET /api/v1/apps/{id}/ui/* | Staattinen tiedostopalvelin | Tarjoilee tiedostot ui/-hakemistostasi (SPA-varareitti tiedostoon index.html) |
ANY /api/v1/apps/{id}/api/* | gRPC-välitys | Välittää HTTP-pyynnöt sovelluksesi metodille UIService.HandleRequest() |
SDK käärii tavallisen net/http.ServeMux-olion, joten kirjoitat tavallisia Go-HTTP-käsittelijöitä — SDK hoitaa gRPC-siltauksen automaattisesti.
Go-esimerkki — koontinäytön käyttöliittymä:
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())
} Tiedostosi ui/index.html tekisi fetch-kutsuja osoitteeseen /api/v1/apps/com.example.dashboard/api/status, jotka välitetään mux-käsittelijällesi.
Ajastussovellus
Ajastussovellus korvaa Nebon sisäänrakennetun cron-ajastimen. Ilmoita "provides": ["schedule"] ja "permissions": ["schedule:create"].
Kun ajastussovelluksesi käynnistyy, Nebo reitittää kaiken ajastuksen sovelluksesi kautta oletusarvoisen cron-moottorin sijaan. Jos sovelluksesi kaatuu, Nebo palaa automaattisesti sisäänrakennettuun moottoriin.
- Sovelluksesi omistaa ajastusten tilan — Nebo ei tallenna ajastuksia omaan tietokantaansa, kun ajastussovellus on aktiivinen
- Tavallinen CRUD:
Create,Get,List,Update,Delete,Enable,Disable Triggerson palvelinpuolen suoratoistava RPC — sovelluksesi lähettää käynnistysviestin aina, kun ajastus laukeaa- Vain yksi ajastussovellus voi olla aktiivisena kerrallaan
Monikykyiset sovellukset
Sovellus voi tarjota useita kykyjä. Esimerkiksi koontinäyttösovellus, jossa on sekä työkalu että käyttöliittymä:
{
"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()) Paketointi
.napp-muoto
Jakelua varten NeboAI:n kautta paketoi sovelluksesi .napp-tiedostoksi (tar.gz-arkisto):
cd com.example.myapp/
tar -czf myapp-1.0.0.napp manifest.json binary signatures.json TOOL.md Pakolliset tiedostot:
| Tiedosto | Enimmäiskoko | Kuvaus |
|---|---|---|
manifest.json | 1 MB | Sovelluksen metatiedot |
binary tai app | 500 MB | Suoritettava tiedosto |
signatures.json | 1 MB | Ed25519-allekirjoitukset |
TOOL.md | 1 MB | Työkaluohjeet tekoälytyöntekijälle |
Purkamisen turvallisuussäännöt:
- Ei polun ohittamista (
../hylätään) - Ei symbolisia linkkejä (hylätään)
- Ei absoluuttisia polkuja (hylätään)
- Vain sallittujen luettelon tiedostonimet hyväksytään
Allekirjoitukset
NeboAI allekirjoittaa sovellukset Ed25519:llä. signatures.json-muoto:
{
"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>"
} Kehitystilassa (NeboAI-URL-osoitetta ei ole määritetty) allekirjoituksen vahvistus ohitetaan kokonaan. Et tarvitse tiedostoa signatures.json paikalliseen kehitykseen.
Julkaiseminen
Kun sovelluksesi toimii paikallisesti, julkaise se NeboAI:n kautta jaettavaksi kaikille Nebon käyttäjille.
Kehittäjätilin käyttöönotto
- Rekisteröi NeboAI-tili osoitteessa
POST /api/v1/owners/register - Kirjaudu sisään saadaksesi JWT-tunnuksen:
POST /api/v1/owners/login - Luo kehittäjätili:
POST /api/v1/developer/accounts
Lähetyksen kulku
draft → pending_review → [approved] → published
→ [rejected] → draft (fix and resubmit) Vaihe 1: Luo sovellus
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"
}' Vaihe 2: Lataa alustakohtaiset binäärit
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" Lataa yksi binääri alustaa kohden: darwin-arm64, darwin-amd64, linux-amd64, linux-arm64.
Vaihe 3: Lähetä tarkistettavaksi
curl -X POST https://neboai.com/api/v1/developer/apps/{id}/submit \
-H "Authorization: Bearer $TOKEN" Tarkistusprosessi
- Automaattinen skannaus — binäärit skannataan VirusTotalilla
- Ylläpitäjän tarkistus — NeboAI-tiimi tarkistaa metatiedot, manifestin ja skannauksen tulokset
- Hyväksyttäessä — NeboAI allekirjoittaa sovelluksen Ed25519:llä ja julkaisee sen
- Hylättäessä — saat perustelun ja voit korjata ja lähettää uudelleen
Tavoiteltu tarkistusaika: <24 tuntia.
Päivitysten julkaiseminen
- Päivitä sovelluksen versio:
PUT /api/v1/developer/apps/{id}uudella versiolla - Lataa uudet binäärit jokaiselle alustalle
- Lähetä uudelleen tarkistettavaksi
Jokainen päivitys käy läpi saman tarkistusprosessin. Aiemmat versiot pysyvät saatavilla, kunnes uusi versio hyväksytään.
Kaupan metatiedot
| Kenttä | Kuvaus |
|---|---|
category | esim. productivity, communication, developer-tools |
icon | Sovelluskuvakkeen URL |
visibility | public tai private |
description | Voi olla pidempi ja monipuolisempi kuin manifestin kuvaus |
Kehitystyönkulku
Paikallinen kehitys
Paikallinen kehitys ei vaadi paketointia:
- Luo sovelluksesi hakemisto:
mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp - Kirjoita
manifest.jsonja koodi - Rakenna binäärisi:
go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary . - Nebo havaitsee uuden hakemiston automaattisesti (tai käynnistä Nebo uudelleen)
- Rakenna binääri uudelleen koodimuutosten jälkeen — tiedostovahti käynnistää sovelluksen uudelleen
Lokien tarkastelu
Sovelluksen stdout/stderr tallennetaan sovelluskohtaisiin lokitiedostoihin:
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 Pysyvä data
Käytä data/-hakemistoa (saatavilla myös ympäristömuuttujana NEBO_APP_DATA) kaikille tiedostoille, jotka sovelluksesi tarvitsee säilyttää. Tämä hakemisto säilyy sovelluspäivitysten ja karanteenin yli.
Vianetsintävinkkejä
- Jos sovelluksesi ei käynnisty, tarkista virheet tiedostosta
logs/stderr.log - Varmista, että binääri on suoritettava (
chmod +x binary) - Varmista, että kuuntelet Unix-socketin polkua, joka on muuttujassa
NEBO_APP_SOCK - Socketin on oltava valmis 10 sekunnin kuluessa käynnistyksestä
- Käytä tallennukseen muuttujaa
NEBO_APP_DATA, älä kovakoodattuja polkuja - Tulosta stderr-virtaan vianetsintälokitusta varten (tallennetaan tiedostoon
logs/stderr.log)
Tarkistaminen
# 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 Asennuksen poistaminen
nebo apps uninstall com.example.myapp Taidot
Mitä taidot ovat
Taidot ovat ohjejoukkoja, jotka muokkaavat Nebon toimintaa keskustelun aikana. Kun taito on aktiivinen, sen sisältö lisätään suoraan järjestelmäkehotteeseen — ja se ohjaa tekoälytyöntekijän sävyä, menetelmiä, alan asiantuntemusta ja työkalujen käyttöä kyseisen istunnon ajan.
Taidot eivät ole koodia. Ne ovat markdown-dokumentteja, joissa on YAML-metatiedot. Ei kääntämistä, ei binääriä, ei gRPC:tä. Taito on SKILL.md-tiedosto hakemistossa. Siinä kaikki.
Taidot ovat tilannekohtaisia ja väliaikaisia. Ne aktivoituvat, kun ne ovat olennaisia (käynnistimen osuman tai manuaalisen latauksen kautta), pysyvät voimassa muutaman vuoron ja vanhenevat, kun niitä ei enää tarvita. Näin tekoälytyöntekijän konteksti pysyy kevyenä — kehotteessa on vain juuri nyt merkityksellinen ohjeistus.
Taidot täydentävät sovelluksia. Sovellukset tarjoavat suoritettavia kykyjä (työkalut, kanavat, yhdyskäytävät). Taidot tarjoavat ohjeistusta niiden yhteiskäyttöön — miten työkaluja käytetään tehokkaasti. Kalenterisovellus antaa Nebolle kyvyn lukea ja kirjoittaa tapahtumia. ”Kokoukseen valmistautuminen” -taito kertoo Nebolle, miten kokouksiin valmistaudutaan käyttämällä kalenterisovellusta, sähköpostia ja verkkohakua yhdessä.
Taidot vs. sovellukset
| Taidot | Sovellukset | |
|---|---|---|
| Muoto | Markdown (SKILL.md) | Käännetty binääri (.napp) |
| Ajonaikainen ympäristö | Lisätään järjestelmäkehotteeseen | Hiekkalaatikoitu prosessi gRPC:n kautta |
| Tarjoaa | Toimintaohjeistusta, menetelmiä | Työkalut, kanavat, käyttöliittymäpaneelit |
| Elinkaari | Istuntokohtainen, vanhenee TTL:n perusteella | Aina käynnissä |
| Luominen | Kirjoita markdown-tiedosto | Kirjoita, käännä, allekirjoita, paketoi |
| Tietoturva | Lupia ei tarvita | Oletuksena kaiken kieltävä hiekkalaatikko |
Pika-aloitus
Luo Nebon taitokansioon hakemisto, jossa on SKILL.md-tiedosto:
~/Library/Application Support/Nebo/skills/ # macOS
~/.config/nebo/skills/ # Linux
%AppData%\Nebo\skills\ # Windows mkdir -p ~/.config/nebo/skills/my-skill Kirjoita 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 seuraa taitohakemistoa fsnotify-työkalulla. Taitosi on käytettävissä heti — uudelleenkäynnistystä ei tarvita. Sano jotain, mikä vastaa käynnistintä, niin se aktivoituu automaattisesti.
Tai pyydä Neboa suoraan: ”Luo taito blogikirjoitusten kirjoittamiseen” — Nebo kirjoittaa SKILL.md-tiedoston puolestasi.
SKILL.md-muoto
Jokainen taito on yksi SKILL.md-tiedosto, jossa on kaksi osaa: YAML-etuosa ----merkkien välissä sekä markdown-runko (varsinaiset ohjeet, jotka lisätään järjestelmäkehotteeseen).
| Kenttä | Pakollinen | Oletus | Kuvaus |
|---|---|---|---|
name | Kyllä | — | Yksilöllinen tunniste (muuttuu slugiksi) |
description | Kyllä | — | Yksirivinen kuvaus, joka näytetään taitoluettelossa |
version | Ei | "1.0.0" | Semver päivitysten seurantaan |
author | Ei | — | Taidon tekijä |
priority | Ei | 0 | Suurempi = osuu ensin (100+ kriittisille ohituksille) |
max_turns | Ei | 4 | Toimettomien vuorojen määrä ennen automaattista vanhenemista |
triggers | Ei | [] | Lausekkeet, jotka aktivoivat tämän taidon automaattisesti (kirjainkoosta riippumaton osamerkkijonovastaavuus) |
tools | Ei | [] | Työkalut, joita tämä taito odottaa käyttävänsä (tiedoksi) |
dependencies | Ei | [] | Muut taidot, jotka on oltava asennettuina |
tags | Ei | [] | Luokittelua ja löydettävyyttä varten |
platform | Ei | [] | Tuetut alustat: macos, linux, windows (tyhjä = kaikki) |
Miten taidot aktivoituvat
Taidot noudattavat kaksivaiheista aktivointimallia: ensin vihje, sitten kutsu.
Vaihe 1: Käynnistimien vastaavuus — Aina kun käyttäjä lähettää viestin, Nebo käy läpi kaikki rekisteröidyt taidot käynnistinosumien varalta. Vastaavat taidot näkyvät vihjeinä järjestelmäkehotteessa. Tekoälytyöntekijä näkee vihjeen ja päättää, kutsuuko se taitoa.
Vaihe 2: Kutsu — Tekoälytyöntekijä kutsuu taitoa näin:
skill(name: "code-review") Tämä palauttaa koko SKILL.md-mallin työkalun tuloksena, kirjaa kutsun ja lisää mallin uudelleen järjestelmäkehotteeseen seuraavilla vuoroilla.
TTL ja vanheneminen:
- Automaattisesti osuneet taidot: 4 toimetonta vuoroa (määritettävissä
max_turns-kentällä) - Manuaalisesti ladatut taidot: 6 toimetonta vuoroa
- Uudelleenkutsu nollaa ajastimen
- Ehdoton raja: enintään 4 aktiivista taitoa istuntoa kohden
- Token-budjetti: aktiivisten taitojen yhteenlaskettu sisältö enintään 16,000 merkkiä
Taitojen hallinta
Tekoälytyöntekijä voi hallita taitoja skill-työkalulla:
| Toiminto | Kuvaus | Esimerkki |
|---|---|---|
catalog | Listaa kaikki käytettävissä olevat taidot | skill(action: "catalog") |
load | Aktivoi tähän istuntoon | skill(name: "code-review", action: "load") |
unload | Poista taito käytöstä | skill(name: "code-review", action: "unload") |
create | Luo uusi taito levylle | skill(action: "create", content: "...") |
update | Päivitä olemassa oleva taito | skill(name: "my-skill", action: "update", content: "...") |
delete | Poista taito levyltä | skill(name: "my-skill", action: "delete") |
Hyvien taitojen kirjoittaminen
Hyvässä taitomallissa on:
- Selkeä otsikko — kertoo tekoälytyöntekijälle, missä tilassa se on
- Perusperiaatteet — ehdottomat toimintasäännöt
- Menetelmät — vaiheittainen lähestymistapa yleisiin tilanteisiin
- Esimerkit — konkreettiset mallit käyttäjän viestistä vastaukseen
- Vastamallit — mitä EI pidä tehdä (mallit oppivat hyvin kielteisistä esimerkeistä)
Vinkki: Jokaisen taidon pitäisi tehdä yksi asia hyvin. Älä luo ”yleisohjelmointi”-taitoa — luo code-review, debugging ja api-design erillisinä taitoina. Tekoälytyöntekijällä voi olla useita aktiivisina samanaikaisesti.
Mukana tulevat taidot
Nebon mukana tulee taitoja, jotka kattavat yleiset käyttötapaukset:
| Taito | Prioriteetti | Kuvaus |
|---|---|---|
onboarding | 100 | Uuden käyttäjän tervehdys ja profiilitietojen keruu |
best-friend | 50 | Persoonallisuustaito — rento, lojaali, suoraa puhetta |
debugging | 25 | Järjestelmällinen vianetsintämenetelmä |
api-design | 15 | RESTful-API-suunnittelun parhaat käytännöt |
code-review | 10 | Jäsennelty koodikatselmointi vakavuustasoineen |
database-expert | 10 | Tietokantasuunnittelu, kyselyt, optimointi |
git-workflow | 10 | Git-haarat, commitit, PR-työnkulut |
security-audit | 10 | Tietoturva-analyysi ja haavoittuvuuksien tunnistus |
Nämä toimivat sekä hyödyllisinä oletuksina että mallitoteutuksina omien taitojen luomiseen.
Viite
Proto-tiedostot
Proto-tiedostot sijaitsevat hakemistossa proto/apps/v0/. SDK:iden mukana tulee valmiiksi generoitu koodi, joten et tarvitse protocia tavalliseen kehitykseen.
| Tiedosto | Palvelu | Keskeiset RPC:t |
|---|---|---|
v0/common.proto | (vain viestit) | 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 |
Jokainen palvelu sisältää RPC:t HealthCheck ja Configure. SDK hoitaa molemmat automaattisesti.
Kanavien proto-tyypit
| Viestityyppi | Kuvaus |
|---|---|
ChannelSendRequest | Lähtevän viestin kuori, jossa on message_id, channelId, sender, text, attachments, reply_to, actions, platform_data |
ChannelSendResponse | Alustan viestin ID ketjutusta varten |
InboundMessage | Saapuvan viestin kuori, jossa on kaikki yhteiset kentät + aikaleima |
MessageSender | Botin identiteetti (name, role, botId) — välittäjä täydentää |
Attachment | Tiedosto-, kuva- tai ääniliite (type, url, filename, size) |
MessageAction | Interaktiivinen painike- tai näppäimistötoiminto (label, callback_id) |
Botin identiteetti ja roolit
Nebo-boteilla on kolmiulotteinen identiteettimalli:
- creature — Mikä botti on (arkkityyppi): ”Nokkela strategi”, ”Huolellinen tutkija”
- role — Miten se suhtautuu käyttäjään (suhde): ”Ystävä”, ”COO”, ”Mentori”
- vibe — Sen energia (viestintätyyli): ”Rento mutta vahvoja mielipiteitä”, ”Lämmin ja kannustava”
Kun kanavalaajennuksesi vastaanottaa lähtevän viestin, sender-kenttä sisältää botin name- ja role-arvot. Käytä niitä näyttönimen muotoiluun alustallesi. Rooli ei ole työnimike — se kuvaa suhdetta. ”Ystävä”, ”Poika” ja ”Mentori” ovat kelvollisia rooleja siinä missä ”COO” ja ”DevLead”.