NeboAI
NeboAI
Anza

Jenga Programu kwa Nebo

Ipe AI yako nguvu mpya za ajabu. Zana, chaneli, gateways, paneli za UI — chochote unachoweza kuwaza, kilichokusanywa kuwa binary asilia.

Muhtasari

Nebo Ni Nini

Nebo ni msaidizi binafsi wa AI wa kompyuta — mfanyakazi wa AI anayefanya kazi kila wakati anayesimamia maisha yako ya kidijitali. Ifikirie Nebo jinsi unavyofikiria simu janja: jukwaa lenye nguvu linaloleta mabadiliko makubwa kupitia programu zake.

Peke yake, Nebo ni mfanyakazi wa AI mwenye uwezo, mwenye kumbukumbu, upangaji ratiba, kuvinjari wavuti, usimamizi wa faili, na ufikiaji wa shell. Lakini ufunguo halisi ni Programu. Kama vile nguvu ya simu janja inavyotokana na mfumo ikolojia wa programu zake, nguvu ya Nebo inatokana na programu zinazopanua kile inachoweza kufanya.

Programu Ni Nini

Programu za Nebo ni vitengo vilivyojitosheleza na vilivyokusanywa mapema vyenye utendaji wa ajabu. Kila programu inaipa Nebo nguvu mpya — usimamizi wa kalenda, kupanga barua pepe, kufuatilia miradi, uendeshaji otomatiki wa nyumba, uchambuzi wa fedha — chochote ambacho msanidi programu anaweza kuwaza.

Programu hutoa nguvu kubwa kwa njia salama sana. Kila programu inaendeshwa ndani ya sandbox yenye ruhusa zinazokataliwa kwa chaguo-msingi. Inaweza kufikia tu kile ambacho manifest yake inatangaza na mtumiaji anaidhinisha.

Kiolesura ni cha mazungumzo kwa 100%. Watumiaji hawatumii programu kupitia skrini au dashibodi tofauti. Wanazungumza na Nebo, na Nebo hutumia zana za programu kukamilisha mambo. "Nina nini kwenye kalenda kesho?" — Nebo huita programu ya kalenda. "Unda mkutano na Sarah saa 3 mchana" — Nebo huita programu ya kalenda. Mtumiaji haachi mazungumzo kamwe.

Programu zinaweza kwa hiari kutoa UI ya mipangilio — paneli ya usanidi inayofunguka katika dirisha la kivinjari lililojengwa ndani ya Nebo. Hapa ndipo watumiaji huingiza funguo za API, kuwasha au kuzima vipengele, na kusanidi programu. UI ya mipangilio inaendeshwa na safu ya settings katika manifest (Nebo huchora fomu kiotomatiki), au programu inaweza kutoa UI yake kamili maalum kupitia uwezo wa ui.

Programu huchukua nafasi ya uwezo uliojengwa ndani ya Nebo na kuupanua. Nebo huja na zana za msingi za jukwaa (ufikiaji wa kalenda ya ndani, picha za skrini, n.k.). Unaposakinisha programu ya kalenda, inachukua nafasi ya zana ya kalenda iliyojengwa ndani na kuwa seti kubwa zaidi — ya ndani + wingu + ujumlishaji + ukaguzi wa upatikanaji.

Sera ya Kukusanywa Pekee

Nebo hutekeleza sera kali ya binary zilizokusanywa pekee. Programu zote lazima ziwe faili tekelezi asilia zilizokusanywa.

HaliLugha
ZinazotumikaGo (inapendekezwa), Rust, C/C++, Zig
ZinazokataliwaPython, Node.js, Ruby, Java, .NET, skripti za shell

Sababu:

  • Kuzuia AI kujibadilisha yenyewe — Mfanyakazi wa AI mwenye ufikiaji wa shell angeweza kubadilisha tabia ya skripti inayofasiriwa wakati inaendeshwa. Binary zilizokusanywa haziwezi kubadilishwa baada ya kusainiwa.
  • Uadilifu wa saini — Saini za Ed25519 hufunika baiti ghafi za binary. Binary iliyosainiwa haiwezi kubadilishwa bila kubatilisha saini.
  • Utekelezaji wa sandbox — Uthibitishaji wa muundo wa binary (magic bytes za ELF/Mach-O/PE) ni lango la haraka na la kuaminika.

Kuanza Haraka

Sakinisha SDK

SDK rasmi hushughulikia usanidi wote wa seva ya gRPC, ushughulikiaji wa ishara, na uunganishaji wa itifaki. Wewe unatekeleza tu violesura vya handler.

Go (inapendekezwa):

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

Rust (inakuja hivi karibuni):

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

C/C++ (inakuja hivi karibuni):

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

Muundo wa Saraka ya Programu

Programu huishi katika saraka ndogo ya apps/ ya saraka yako ya data ya Nebo:

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

Orodha ya Ukaguzi ya Programu ya Msingi

  1. Unda manifest.json yenye id, name, version, provides
  2. Andika TOOL.md inayoeleza jinsi mfanyakazi wa AI anavyopaswa kutumia zana yako
  3. Sakinisha SDK (go get github.com/neboloop/nebo-sdk-go)
  4. Tekeleza kiolesura cha handler kwa uwezo wako (ToolHandler, ChannelHandler, n.k.)
  5. Sajili handler na uite app.Run()
  6. Jenga binary asilia (go build -o binary .)
  7. Weka binary + manifest.json + TOOL.md katika saraka ya apps/<your-app-id>/
  8. Nebo huigundua na kuizindua kiotomatiki

Usanidi

manifest.json

Kila programu inahitaji 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
        }
    ]
}

Sehemu zinazohitajika:

SehemuMaelezo
idKitambulisho cha domain-kinyume (k.m., com.mycompany.myapp)
nameJina linalosomeka na binadamu
versionMfuatano wa semver
providesAngalau uwezo mmoja (tazama hapa chini)

Sehemu za hiari:

SehemuChaguo-msingiMaelezo
runtime"local""local" au "remote"
protocol"grpc""grpc" pekee ndiyo inayotumika
permissions[]Kile ambacho programu inahitaji kufikia
description""Huonyeshwa kwenye UI
settings[]Mipangilio inayoweza kusanidiwa (huchorwa katika UI ya Mipangilio)
oauth[]Mahitaji ya mtoa huduma wa OAuth (tazama sehemu ya OAuth hapa chini)

Uwezo

Tangaza kile ambacho programu yako inatoa:

UwezoHuduma ya gRPCMaelezo
gatewayGatewayServiceUelekezaji wa miundo ya LLM
tool:<name>ToolServiceZana yenye jina kwa ajili ya mfanyakazi wa AI
channel:<name>ChannelServiceChaneli ya ujumbe
commCommServiceMawasiliano kati ya wafanyakazi wa AI
uiUIServiceUI maalum yenye HTTP proxy
scheduleScheduleServiceUpangaji ratiba maalum
visionToolServiceUchakataji wa picha
browserToolServiceUendeshaji otomatiki wa kivinjari

Programu inaweza kutoa uwezo mwingi. Kwa mfano, programu inaweza kutoa zana na paneli ya UI kwa pamoja.

Ruhusa

Ruhusa hudhibiti kile ambacho programu inaweza kufikia. Kukataa kwa chaguo-msingi — ikiwa haijatangazwa, programu haiwezi kuitumia.

Kiambishi awaliMifanoMaelezo
network:network:outbound, network:*Ufikiaji wa mtandao
filesystem:filesystem:read, filesystem:writeUfikiaji wa mfumo wa faili
memory:memory:read, memory:writeUfikiaji wa kumbukumbu ya mfanyakazi wa AI
session:session:readVipindi vya mazungumzo
tool:tool:shell, tool:fileTumia zana nyingine
shell:shell:execUtekelezaji wa amri za shell
channel:channel:send, channel:*Shughuli za chaneli
comm:comm:send, comm:*Mawasiliano kati ya wafanyakazi wa AI
model:model:chatUfikiaji wa miundo ya AI
user:user:tokenPokea JWT ya mtumiaji katika maombi
schedule:schedule:createUsimamizi wa kazi za cron
database:database:queryUfikiaji wa hifadhidata
storage:storage:read, storage:writeHifadhi ya kudumu
context:context:readUfikiaji wa muktadha wa mfanyakazi wa AI
subagent:subagent:spawnShughuli za sub-agent
lane:lane:enqueueShughuli za lane
notification:notification:sendArifa za push
embedding:embedding:searchUfikiaji wa vector embedding
skill:skill:invokeKuita ujuzi
advisor:advisor:consultUfikiaji wa mfumo wa ushauri
mcp:mcp:connectUfikiaji wa seva ya MCP
voice:voice:recordUfikiaji wa sauti
browser:browser:navigateUendeshaji otomatiki wa kivinjari
oauth:oauth:google, oauth:*Ufikiaji wa tokeni ya OAuth
settings:settings:readUfikiaji wa mipangilio
capability:capability:registerUsajili wa uwezo

Ruhusa za wildcard zinatumika: network:* inalingana na ukaguzi wowote wa ruhusa ya network:.

Mipangilio

Mipangilio huonekana kwenye UI ya Nebo chini ya paneli ya mipangilio ya programu. Nebo huihifadhi kwenye hifadhidata na kuituma kwa programu yako kupitia RPC ya Configure inapobadilika.

Schema yako ya mipangilio imejumuishwa kwenye tangazo la duka la programu la NeboAI. Programu zenye mipangilio inayohitajika ambayo haijasanidiwa huonyesha beji ya "Inahitaji Kuwekwa" kwenye UI.

AinaMaelezo
textKisanduku cha maandishi cha mstari mmoja
passwordKisanduku cha maandishi kilichofichwa
toggleSwichi ya kuwasha/kuzima ya Boolean
selectMenyu kunjuzi yenye chaguzi zilizobainishwa
numberKisanduku cha namba
urlKisanduku cha URL chenye uthibitishaji
{
    "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"}
    ]
}

Mahitaji ya OAuth

Programu zinaweza kutangaza mahitaji ya mtoa huduma wa OAuth. OAuth broker ya Nebo hushughulikia mtiririko wote — programu hupokea tokeni kiotomatiki kupitia RPC ya Configure.

{
    "oauth": [
        {
            "provider": "google",
            "scopes": ["https://www.googleapis.com/auth/calendar"]
        }
    ]
}
SehemuMaelezo
providerMtoa huduma wa OAuth: "google", "microsoft", "github"
scopesSafu ya scopes za OAuth ambazo programu inahitaji

Mtumiaji anaposakinisha programu, Nebo humwomba aidhinishe scopes za OAuth zinazohitajika. Programu hupokea tokeni zilizoonyeshwa upya kupitia RPC ya Configure bila kushughulikia mtiririko wa OAuth yenyewe.

Vigezo vya Mazingira

Mchakato wa programu yako hupokea mazingira yaliyosafishwa. Siri zote huondolewa. Unapata:

KigezoThamani
NEBO_APP_DIRSaraka ya usakinishaji wa programu
NEBO_APP_SOCKNjia ya Unix socket ya kuunda
NEBO_APP_IDID ya programu kutoka manifest
NEBO_APP_NAMEJina la programu kutoka manifest
NEBO_APP_VERSIONToleo la programu kutoka manifest
NEBO_APP_DATANjia ya saraka ya data/ ya programu
PATHPATH ya mfumo (inapitishwa)
HOMESaraka ya nyumbani ya mtumiaji (inapitishwa)
TMPDIRSaraka ya muda (inapitishwa)

Muhimu sana: Binary yako lazima iunde seva ya gRPC inayosikiliza kwenye Unix socket iliyo NEBO_APP_SOCK. Nebo husubiri hadi sekunde 10 socket hii ionekane.

Mfuatano wa Kuzindua Programu

  1. Nebo husoma manifest.json na kuithibitisha
  2. Hutafuta faili tekelezi ya binary au app katika saraka ya programu
  3. Hukagua alama ya .quarantined (hukataa kuzindua programu zilizotengwa)
  4. Ukaguzi wa ubatilishaji (programu zinazosambazwa na NeboAI pekee)
  5. Uthibitishaji wa saini (programu zinazosambazwa na NeboAI pekee, hurukwa katika dev)
  6. Uthibitishaji wa binary (hukataa symlinks, skripti, faili zisizo tekelezi, faili kubwa kupita kiasi)
  7. Husafisha socket ya zamani kutoka utekelezaji uliopita
  8. Huunda saraka ya data/ kwa hifadhi iliyo ndani ya sandbox
  9. Huweka faili za kumbukumbu kwa kila programu (logs/stdout.log, logs/stderr.log)
  10. Huanzisha binary kwa mazingira yaliyosafishwa na utengaji wa kikundi cha michakato
  11. Husubiri Unix socket ionekane (exponential backoff, upeo wa sekunde 10)
  12. Huunganisha kupitia gRPC juu ya Unix socket
  13. Huunda wateja wa gRPC maalum kwa kila uwezo kulingana na provides
  14. Huendesha ukaguzi wa afya
  15. Husajili uwezo kwa mfanyakazi wa AI (zana, gateway, comm, n.k.)

Programu za Zana

Tangaza "provides": ["tool:my_tool_name"] katika manifest yako.

Mtindo wa STRAP

Programu zote za zana za Nebo lazima zitumie STRAP (Single Tool Resource Action Pattern) kwa schema yao na uelekezaji wa utekelezaji. Huu ndio mtindo ule ule ambao Nebo hutumia ndani kuunganisha zana 35+ binafsi kuwa zana 4 za nyanja — ikipunguza mzigo wa muktadha wa LLM kwa ~80%.

Wazo kuu: Badala ya kusajili zana nyingi (get_events, check_availability, suggest_slots), sajili zana MOJA yenye sehemu za action (na kwa hiari resource) zinazoelekeza kwa handler sahihi.

Mfano wa rasilimali moja (kalenda):

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

Mfano wa rasilimali nyingi (msimamizi wa miradi):

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

Sheria za schema:

  1. Jumuisha kila wakati sehemu ya action kama string enum inayohitajika
  2. Ongeza sehemu ya resource (string enum inayohitajika) ikiwa tu zana yako inasimamia aina nyingi tofauti za rasilimali
  3. Sehemu nyingine zote ni vigezo maalum vya kila action
  4. Maelezo ya enum ya action yanapaswa kuorodhesha actions zote zinazopatikana

Kwa nini STRAP ni muhimu:

  • LLM hujifunza mtindo wa uelekezaji wa action mara moja na kuutumia kwa shughuli zote
  • Ufafanuzi wa zana hutumia ~6% ya muktadha — STRAP hupunguza hilo kwa 80%
  • Shughuli mpya ni nyongeza za enum tu, si usajili mpya wa zana
  • Inafanya kazi sawasawa kwenye miundo inayokaribishwa na ya ndani

Mfano wa Go — Zana ya Kikokotoo

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

Jenga na usakinishe:

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/

Mfano wa 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(())
}

Mfano wa 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;
}

Programu za Chaneli

Tangaza "provides": ["channel:my_channel"] na "permissions": ["channel:send"].

Programu za chaneli huunganisha majukwaa ya nje ya ujumbe (Telegram, Discord, Slack, n.k.) na mfanyakazi wa AI wa Nebo. Mtumiaji anapotuma ujumbe kwenye jukwaa la nje, programu yako huutiririsha kwa Nebo kupitia Receive. Mfanyakazi wa AI anapotaka kujibu, Nebo huita Send ya programu yako.

Jinsi inavyofanya kazi

  1. Nebo huita ID() kupata kitambulisho cha kipekee cha chaneli yako
  2. Nebo huita Connect() pamoja na config kutoka mipangilio ya programu yako
  3. Nebo hufungua mkondo wa Receive() — programu yako hutuma jumbe zinazoingia kila mtumiaji anapoitumia boti ujumbe
  4. Jumbe zinazoingia huelekezwa kwenye lane kuu ya mazungumzo ya mfanyakazi wa AI
  5. Mfanyakazi wa AI anapotaka kutuma ujumbe, Nebo huita Send() pamoja na bahasha ya ujumbe ya v1
  6. Wakati wa kuzima, Nebo huita Disconnect()

Bahasha ya Ujumbe ya v1

Jumbe zote za chaneli — zinazoingia na zinazotoka — hutumia bahasha ya pamoja ya ujumbe:

{
  "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"
}
SehemuAinaMaelezo
message_idUUID v7ID ya kipekee iliyopangwa kwa wakati
channel_id{type}:{platform_id}Kitambulisho cha chaneli kinachoweza kuelekezwa
senderobjectUtambulisho wa boti — name, role, botId
textstringKiini cha ujumbe
attachmentsarrayFaili, picha, sauti
reply_toUUID v7ID ya ujumbe mzazi kwa ajili ya mfululizo
actionsarrayVitufe/kibodi shirikishi
platform_databytesUpitishaji usioonekana kwa vipengele maalum vya jukwaa
timestampISO 8601Mchapishaji huweka hii

Muundo wa tabaka mbili: Sehemu za pamoja (text, attachments, reply_to, actions) hufunika 90% ya jumbe zinazoanzishwa na mfanyakazi. Vipengele maalum vya jukwaa huenda katika platform_data — programu-jalizi yako huvigeuza kwenda/kutoka muundo asilia wa jukwaa.

Mikondo ya Mazungumzo

Jumbe za chaneli huelekezwa kupitia mikondo ya mazungumzo ya kila chaneli kwa ajili ya utengaji:

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

Mfano wa Go — Chaneli ya 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
        }
    ]
}

Uwezo Zaidi

Programu ya Comm

Tangaza "provides": ["comm"] na "permissions": ["comm:*"]. Programu za comm huwezesha mawasiliano kati ya wafanyakazi wa AI.

SehemuMaelezo
fromID ya mfanyakazi anayetuma
toID ya mfanyakazi anayepokea
topicMada/chaneli ya ujumbe
type"message", "mention", "proposal", "command", "info", "task"
contentKiini cha ujumbe

Tabia muhimu:

  • Register humtangaza mfanyakazi huyu wa AI kwenye mtandao pamoja na uwezo wake
  • Subscribe/Unsubscribe husimamia usajili wa mada
  • Receive hutiririsha jumbe zinazoingia (server-streaming, sawa na chaneli)
  • Programu moja tu ya comm inaweza kuwa hai kwa wakati mmoja

Programu ya Gateway

Programu ya gateway huelekeza maombi ya LLM kwa miundo. Tangaza "provides": ["gateway"] na "permissions": ["network:outbound", "user:token"].

GatewayRequest ina jumbe, zana, system prompt, max tokens, temperature, na UserContext (tokeni ya JWT ikiwa ruhusa ya user:token imetolewa).

Aina za GatewayEvent:

AinaMaudhuiMaelezo
"text"Kipande cha maandishiTokeni ya maandishi inayotiririshwa
"tool_call"JSONMuundo unataka kuita zana
"thinking"Kipande cha maandishiKufikiri/kutafakari kwa kina
"error"Ujumbe wa hitilafuKuna tatizo limetokea
"done"TupuMkondo umekamilika

Programu ya UI

Programu ya UI hutoa kiolesura maalum cha usanidi kinachofunguka katika dirisha la kivinjari lililojengwa ndani ya Nebo. Tangaza "provides": ["ui"]. Tofauti na fomu ya mipangilio ya kiotomatiki (ambayo Nebo huichora kutoka kwa manifest yako ya settings), programu ya UI hutoa frontend yake kamili ya HTML/CSS/JS.

Programu yako huja na saraka ya ui/ yenye rasilimali tuli za wavuti (HTML, CSS, JS — kwa kawaida SPA yenye index.html). Nebo hutoa faili hizi moja kwa moja na kupitisha maombi ya API kwa programu yako kupitia gRPC.

NjiaUtaratibuMadhumuni
GET /api/v1/apps/{id}/ui/*Seva ya faili tuliHutoa faili kutoka saraka yako ya ui/ (SPA hurudi kwa index.html)
ANY /api/v1/apps/{id}/api/*gRPC proxyHupitisha maombi ya HTTP kwa UIService.HandleRequest() ya programu yako

SDK hufunika net/http.ServeMux ya kawaida ili uandike HTTP handlers za kawaida za Go — SDK hushughulikia uunganishaji wa gRPC kiotomatiki.

Mfano wa Go — UI ya Dashibodi:

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 yako ingefanya maombi ya fetch kwa /api/v1/apps/com.example.dashboard/api/status, ambayo hupitishwa hadi kwa handler yako ya mux.

Programu ya Ratiba

Programu ya ratiba huchukua nafasi ya kipanga ratiba cha cron kilichojengwa ndani ya Nebo. Tangaza "provides": ["schedule"] na "permissions": ["schedule:create"].

Programu yako ya ratiba inapozinduliwa, Nebo huelekeza upangaji ratiba wote kupitia programu yako badala ya injini ya cron ya chaguo-msingi. Programu yako ikianguka, Nebo hurudi kiotomatiki kwa injini iliyojengwa ndani.

  • Programu yako inamiliki hali ya ratiba — Nebo haihifadhi ratiba katika DB yake yenyewe wakati programu ya ratiba iko hai
  • CRUD ya kawaida: Create, Get, List, Update, Delete, Enable, Disable
  • Triggers ni RPC ya server-streaming — programu yako hutuma ujumbe wa kichochezi kila ratiba inapotekelezwa
  • Programu moja tu ya ratiba inaweza kuwa hai kwa wakati mmoja

Programu zenye Uwezo Mwingi

Programu inaweza kutoa uwezo mwingi. Kwa mfano, programu ya dashibodi yenye zana na UI kwa pamoja:

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

Ufungashaji

Muundo wa .napp

Kwa usambazaji kupitia NeboAI, funga programu yako kama faili ya .napp (kumbukumbu ya tar.gz):

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

Faili zinazohitajika:

FailiUkubwa wa JuuMaelezo
manifest.json1 MBMetadata ya programu
binary au app500 MBFaili tekelezi
signatures.json1 MBSaini za Ed25519
TOOL.md1 MBMaelekezo ya zana kwa mfanyakazi wa AI

Sheria za usalama wakati wa kufungua:

  • Hakuna path traversal (../ inakataliwa)
  • Hakuna symlinks (zinakataliwa)
  • Hakuna njia kamili (zinakataliwa)
  • Majina ya faili yaliyo kwenye orodha ya kuruhusiwa pekee ndiyo yanayokubaliwa

Saini

NeboAI husaini programu kwa Ed25519. Muundo wa 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>"
}

Katika hali ya dev (hakuna URL ya NeboAI iliyosanidiwa), uthibitishaji wa saini hurukwa kabisa. Huhitaji signatures.json kwa uundaji wa ndani.

Kuchapisha

Programu yako ikishafanya kazi ndani, ichapishe kupitia NeboAI ili isambazwe kwa watumiaji wote wa Nebo.

Kuweka Akaunti ya Msanidi Programu

  1. Sajili akaunti ya NeboAI kwenye POST /api/v1/owners/register
  2. Ingia ili kupata tokeni ya JWT: POST /api/v1/owners/login
  3. Unda akaunti ya msanidi programu: POST /api/v1/developer/accounts

Mtiririko wa Uwasilishaji

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

Hatua ya 1: Unda programu

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

Hatua ya 2: Pakia binary za majukwaa

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"

Pakia binary moja kwa kila jukwaa: darwin-arm64, darwin-amd64, linux-amd64, linux-arm64.

Hatua ya 3: Wasilisha kwa ukaguzi

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

Mchakato wa Ukaguzi

  1. Uchanganuzi wa kiotomatiki — binary huchanganuliwa kupitia VirusTotal
  2. Ukaguzi wa msimamizi — timu ya NeboAI hukagua metadata, manifest, na matokeo ya uchanganuzi
  3. Ikiidhinishwa — NeboAI husaini programu kwa Ed25519 na kuichapisha
  4. Ikikataliwa — unapokea sababu na unaweza kurekebisha na kuwasilisha tena

Muda unaolengwa wa ukaguzi: <24 saa.

Kutuma Masasisho

  1. Sasisha toleo la programu: PUT /api/v1/developer/apps/{id} ukiwa na toleo jipya
  2. Pakia binary mpya kwa kila jukwaa
  3. Wasilisha kwa ukaguzi tena

Kila sasisho hupitia mchakato ule ule wa ukaguzi. Matoleo ya awali yanaendelea kupatikana hadi toleo jipya liidhinishwe.

Metadata ya Duka

SehemuMaelezo
categoryk.m., productivity, communication, developer-tools
iconURL ya aikoni ya programu
visibilitypublic au private
descriptionInaweza kuwa ndefu/tajiri zaidi kuliko maelezo ya manifest

Mtiririko wa Uundaji

Uundaji wa Ndani

Hakuna ufungashaji unaohitajika kwa uundaji wa ndani:

  1. Unda saraka ya programu yako:
    mkdir -p ~/Library/Application\ Support/Nebo/apps/com.example.myapp
  2. Andika manifest.json yako na msimbo
  3. Jenga faili lako la binary:
    go build -o ~/Library/Application\ Support/Nebo/apps/com.example.myapp/binary .
  4. Nebo hugundua saraka mpya kiotomatiki (au anzisha upya Nebo)
  5. Baada ya mabadiliko ya msimbo, jenga upya binary — kifuatiliaji cha faili kitaanzisha upya programu

Kutazama Kumbukumbu

stdout/stderr ya programu hunaswa katika faili za kumbukumbu za kila programu:

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 ya Kudumu

Tumia saraka ya data/ (inapatikana pia kama env var ya NEBO_APP_DATA) kwa faili zozote ambazo programu yako inahitaji kuhifadhi. Saraka hii hudumu hata baada ya masasisho ya programu na kutengwa.

Vidokezo vya Utatuzi

  • Ikiwa programu yako haianzi, angalia logs/stderr.log kwa hitilafu
  • Hakikisha binary inaweza kutekelezwa (chmod +x binary)
  • Hakikisha unasikiliza kwenye njia ya Unix socket kutoka NEBO_APP_SOCK
  • Socket lazima iwe tayari ndani ya sekunde 10 baada ya kuzinduliwa
  • Tumia NEBO_APP_DATA kwa hifadhi, si njia zilizoandikwa moja kwa moja kwenye msimbo
  • Chapisha kwenye stderr kwa kumbukumbu za utatuzi (hunaswa katika logs/stderr.log)

Kuthibitisha

# 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

Kuondoa usakinishaji

nebo apps uninstall com.example.myapp

Ujuzi

Ujuzi Ni Nini

Ujuzi ni seti za maelekezo zinazounda jinsi Nebo inavyotenda wakati wa mazungumzo. Ujuzi unapokuwa hai, maudhui yake huingizwa moja kwa moja kwenye system prompt — yakiongoza sauti, mbinu, utaalamu wa fani, na matumizi ya zana ya mfanyakazi wa AI kwa kipindi hicho.

Ujuzi si msimbo. Ni nyaraka za markdown zenye metadata ya YAML. Hakuna ukusanyaji, hakuna binary, hakuna gRPC. Ujuzi ni faili ya SKILL.md katika saraka. Hiyo tu.

Ujuzi ni wa muktadha na wa muda. Huwashwa unapohusika (kupitia ulinganishaji wa vichochezi au kupakiwa kwa mkono), hudumu kwa zamu chache, na huisha muda usipohitajika tena. Hii huweka muktadha wa mfanyakazi wa AI ukiwa mwepesi — mwongozo unaohusika sasa hivi pekee ndio ulio kwenye prompt.

Ujuzi hukamilisha programu. Programu hutoa uwezo unaotekelezeka (zana, chaneli, gateways). Ujuzi hutoa mwongozo wa uratibu — jinsi ya kutumia zana hizo kwa ufanisi. Programu ya kalenda huipa Nebo uwezo wa kusoma na kuandika matukio. Ujuzi wa "kujiandaa kwa mkutano" huiambia Nebo jinsi ya kujiandaa kwa mikutano ikitumia programu hiyo ya kalenda, barua pepe, na utafutaji wa wavuti kwa pamoja.

Ujuzi dhidi ya Programu

UjuziProgramu
MuundoMarkdown (SKILL.md)Binary iliyokusanywa (.napp)
Wakati wa utekelezajiHuingizwa kwenye system promptMchakato ndani ya sandbox kupitia gRPC
HutoaMwongozo wa tabia, mbinuZana, chaneli, paneli za UI
Muda wa kuishiKwa kipindi, huisha muda kwa TTLHuendeshwa kila wakati
UundajiAndika faili ya markdownAndika, kusanya, saini, funga
UsalamaHakuna ruhusa zinazohitajikaSandbox ya kukataa kwa chaguo-msingi

Kuanza Haraka

Unda saraka katika folda yako ya ujuzi ya Nebo yenye faili ya SKILL.md:

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

Andika 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 hufuatilia saraka ya ujuzi kwa fsnotify. Ujuzi wako unapatikana mara moja — hakuna haja ya kuanzisha upya. Sema kitu kinacholingana na kichochezi, na unawashwa kiotomatiki.

Au iulize Nebo moja kwa moja: "Unda ujuzi wa kuandika machapisho ya blogu" — Nebo itakuandikia faili ya SKILL.md.

Muundo wa SKILL.md

Kila ujuzi ni faili moja ya SKILL.md yenye sehemu mbili: frontmatter ya YAML kati ya alama za ---, na kiini cha markdown (maelekezo halisi yanayoingizwa kwenye system prompt).

SehemuInahitajikaChaguo-msingiMaelezo
nameNdiyo—Kitambulisho cha kipekee (kinakuwa slug)
descriptionNdiyo—Maelezo ya mstari mmoja yanayoonyeshwa kwenye katalogi ya ujuzi
versionHapana"1.0.0"Semver ya kufuatilia masasisho
authorHapana—Mwandishi wa ujuzi
priorityHapana0Juu zaidi = hulinganishwa kwanza (100+ kwa mabadiliko muhimu ya kipaumbele)
max_turnsHapana4Zamu za kutokuwa na shughuli kabla ya kuisha muda kiotomatiki
triggersHapana[]Vifungu vya maneno vinavyowasha ujuzi huu kiotomatiki (ulinganishaji wa sehemu ya maandishi bila kujali herufi kubwa au ndogo)
toolsHapana[]Zana ambazo ujuzi huu unatarajia kutumia (kwa taarifa)
dependenciesHapana[]Ujuzi mwingine ambao lazima usakinishwe
tagsHapana[]Kwa kupanga katika makundi na ugunduzi
platformHapana[]Majukwaa yanayotumika: macos, linux, windows (tupu = yote)

Jinsi Ujuzi Unavyowashwa

Ujuzi hufuata mtindo wa uwashaji wa awamu mbili: dokezo kisha kuita.

Awamu ya 1: Ulinganishaji wa Vichochezi — Kila mara mtumiaji anapotuma ujumbe, Nebo huchanganua ujuzi wote uliosajiliwa kutafuta vichochezi vinavyolingana. Ujuzi unaolingana huonekana kama madokezo kwenye system prompt. Mfanyakazi wa AI huona dokezo na kuamua kama aite ujuzi huo.

Awamu ya 2: Kuita — Mfanyakazi wa AI huita ujuzi kwa kuita:

skill(name: "code-review")

Hii hurudisha kiolezo kamili cha SKILL.md kama tokeo la zana, hurekodi wito huo, na huingiza tena kiolezo kwenye system prompt katika zamu zinazofuata.

TTL na Kuisha Muda:

  • Ujuzi unaolinganishwa kiotomatiki: zamu 4 za kutokuwa na shughuli (inasanidiwa kupitia max_turns)
  • Ujuzi unaopakiwa kwa mkono: zamu 6 za kutokuwa na shughuli
  • Kuita tena huweka upya kipima muda
  • Kikomo kikali: upeo wa ujuzi 4 hai kwa kila kipindi
  • Bajeti ya tokeni: maudhui ya ujuzi hai kwa pamoja yana kikomo cha herufi 16,000

Kusimamia Ujuzi

Mfanyakazi wa AI anaweza kusimamia ujuzi kupitia zana ya skill:

KitendoMaelezoMfano
catalogOrodhesha ujuzi wote unaopatikanaskill(action: "catalog")
loadWasha kwa kipindi hikiskill(name: "code-review", action: "load")
unloadZima ujuziskill(name: "code-review", action: "unload")
createUnda ujuzi mpya kwenye diskiskill(action: "create", content: "...")
updateSasisha ujuzi ulioposkill(name: "my-skill", action: "update", content: "...")
deleteFuta ujuzi kutoka kwenye diskiskill(name: "my-skill", action: "delete")

Kuandika Ujuzi Mzuri

Kiolezo kizuri cha ujuzi kina:

  1. Kichwa kilicho wazi — kinamwambia mfanyakazi wa AI yuko katika hali gani
  2. Kanuni za msingi — sheria za tabia zisizojadilika
  3. Mbinu — njia ya hatua kwa hatua kwa hali za kawaida
  4. Mifano — mifumo halisi ya ujumbe wa mtumiaji hadi jibu
  5. Mifumo ya kuepuka — kile USICHOPASWA kufanya (miundo hujifunza vizuri kutokana na mifano hasi)

Kidokezo: Kila ujuzi unapaswa kufanya jambo moja vizuri. Usiunde ujuzi wa "programu kwa ujumla" — unda code-review, debugging, api-design kama ujuzi tofauti. Mfanyakazi wa AI anaweza kuwa na mingi hai kwa wakati mmoja.

Ujuzi Uliojumuishwa

Nebo huja na ujuzi uliojumuishwa unaoshughulikia matumizi ya kawaida:

UjuziKipaumbeleMaelezo
onboarding100Kumkaribisha mtumiaji mpya na kukusanya wasifu
best-friend50Ujuzi wa haiba — wa kawaida, mwaminifu, mazungumzo ya ukweli
debugging25Mbinu ya utatuzi wa kimfumo
api-design15Mbinu bora za kubuni API za RESTful
code-review10Ukaguzi wa msimbo uliopangwa kwa viwango vya uzito
database-expert10Kubuni hifadhidata, maswali, uboreshaji
git-workflow10Matawi ya Git, commits, mitiririko ya PR
security-audit10Uchambuzi wa usalama na kugundua udhaifu

Hivi hutumika kama chaguo-msingi muhimu na pia kama mifano ya marejeleo ya kuunda ujuzi wako mwenyewe.

Marejeleo

Faili za Proto

Faili za proto huishi katika proto/apps/v0/. SDK huja na msimbo uliozalishwa mapema, kwa hiyo huhitaji protoc kwa uundaji wa kawaida.

FailiHudumaRPC Muhimu
v0/common.proto(jumbe pekee)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

Kila huduma inajumuisha RPC za HealthCheck na Configure. SDK hushughulikia zote mbili kiotomatiki.

Aina za Proto za Chaneli

Aina ya UjumbeMaelezo
ChannelSendRequestBahasha ya ujumbe unaotoka yenye message_id, channelId, sender, text, attachments, reply_to, actions, platform_data
ChannelSendResponseID ya ujumbe ya jukwaa kwa ajili ya mfululizo
InboundMessageBahasha ya ujumbe unaoingia yenye sehemu zote za pamoja + timestamp
MessageSenderUtambulisho wa boti (name, role, botId) — huboreshwa na broker
AttachmentKiambatisho cha faili/picha/sauti (type, url, filename, size)
MessageActionKitendo cha kitufe/kibodi shirikishi (label, callback_id)

Utambulisho na Nafasi za Boti

Boti za Nebo zina mtindo wa utambulisho wa mihimili mitatu:

  • creature — Boti ni nini (aina ya msingi): "Mwanamkakati mwenye akili ya haraka", "Mtafiti makini"
  • role — Inavyohusiana na mtumiaji (uhusiano): "Rafiki", "COO", "Mshauri"
  • vibe — Nguvu yake (mtindo wa mawasiliano): "Mtulivu lakini mwenye msimamo", "Mchangamfu na mwenye kutia moyo"

Programu-jalizi yako ya chaneli inapopokea ujumbe unaotoka, sehemu ya sender ina name na role ya boti. Tumia hii kuunda jina la kuonyesha kwa jukwaa lako. Role si cheo cha kazi — ni kielelezo cha uhusiano. "Rafiki", "Mwana", na "Mshauri" ni roles halali pamoja na "COO" na "DevLead".