കരാർ
Unix സോക്കറ്റിലുള്ള ഒരു gRPC സെർവറാണ് സൈഡ്കാർ. NEBO_APP_SOCK-ലെ പാത്തിൽ ശ്രദ്ധിക്കുകയും apps.v0.UIService നടപ്പാക്കുകയും ചെയ്യൂ. Nebo ഓരോ അഭ്യർഥനയ്ക്കും HandleRequest വിളിക്കുന്നു; HealthCheck, Configure എന്നിവ സേവനത്തിന്റെ ഭാഗമാണെങ്കിലും ഇന്ന് വിളിക്കുന്നില്ല. മാനിഫെസ്റ്റിലെ startup_timeout-നുള്ളിൽ സോക്കറ്റ് പ്രത്യക്ഷപ്പെടണം, അതിന്റെ ഡിഫോൾട്ട് 10 സെക്കൻഡാണ്, പരമാവധി 120 ആകാം.
syntax = "proto3";
package apps.v0;
service UIService {
rpc HealthCheck(HealthCheckRequest) returns (HealthCheckResponse);
rpc Configure(SettingsMap) returns (Empty);
rpc HandleRequest(HttpRequest) returns (HttpResponse);
}
message HttpRequest {
string method = 1; // GET, POST, PUT, DELETE, ...
string path = 2; // relative to /apps/{id}/api/
string query = 3; // raw query string
map<string, string> headers = 4;
bytes body = 5;
}
message HttpResponse {
int32 status_code = 1;
map<string, string> headers = 2;
bytes body = 3;
} സൈഡ്കാറുകൾ macOS-ലും Linux-ലും പ്രവർത്തിക്കുന്നു.
Nebo ബൈനറി എവിടെ കണ്ടെത്തുന്നു
ആപ്പിന്റെ ഫോൾഡറിൽ, ഇവയിൽ നിലവിലുള്ള ആദ്യത്തേത് Nebo ഉപയോഗിക്കുന്നു:
binaryഎന്ന് പേരുള്ള ഒരു ഫയൽappഎന്ന് പേരുള്ള ഒരു ഫയൽtmp/-ലെ ആദ്യ ഫയൽbin/-ലെ ആദ്യ ഫയൽ- ലോക്കൽ ഡെവലപ്മെന്റിനായി,
sidecar/target/release/-ലെ ആദ്യ എക്സിക്യൂട്ടബിൾ
ബൈനറി ഒരു സാധാരണ, എക്സിക്യൂട്ടബിൾ ഫയലായിരിക്കണം, സിംബോളിക് ലിങ്കല്ല, പരമാവധി 500 MB. പ്രസിദ്ധീകരിച്ച ആപ്പുകൾ അത് bin/<name>-ൽ സൂക്ഷിക്കുന്നു. ഡിസ്കിൽ ഫയൽ മാറുമ്പോൾ, Nebo സൈഡ്കാർ പുനരാരംഭിക്കും.
എൻവയോൺമെന്റ്
ശൂന്യമായ എൻവയോൺമെന്റും ഈ വേരിയബിളുകളുമായാണ് സൈഡ്കാർ തുടങ്ങുന്നത്:
| വേരിയബിൾ | മൂല്യം |
|---|---|
NEBO_APP_ID, NEBO_APP_NAME, NEBO_APP_VERSION | ആപ്പിന്റെ ഐഡന്റിറ്റി. |
NEBO_APP_DIR | ആപ്പിന്റെ ഫോൾഡർ. |
NEBO_APP_SOCK | ശ്രദ്ധിക്കേണ്ട സോക്കറ്റ്, <app folder>/<id>.sock. Nebo അതിന്റെ മോഡ് 0600 ആയി സജ്ജമാക്കുന്നു. |
NEBO_DATA_DIR | ആപ്പിന്റെ ഡാറ്റ ഫോൾഡർ, <data>/appdata/agents/<id>/. വർക്കിങ് ഡയറക്ടറിയും ഇതുതന്നെ. |
NEBO_API_URL | ബോട്ടിന്റെ ലോക്കൽ API, http://127.0.0.1:<port>. |
NEBO_APP_TOKEN | ബോട്ടിന്റെ ആപ്പ് API വിളിക്കാനുള്ള ഒരു ടോക്കൺ. |
PATH, HOME, TMPDIR, LANG, LC_ALL, TZ | അതേപടി കൈമാറുന്നു. |
സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടും സ്റ്റാൻഡേർഡ് എററും ഡാറ്റ ഫോൾഡറിലെ sidecar.log-ലേക്ക് പോകുന്നു. സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് ഒരു പൈപ്പാണ്; ഫയലിന്റെ അവസാനം എന്നാൽ Nebo പോയിക്കഴിഞ്ഞു, സൈഡ്കാർ പുറത്തുകടക്കണം എന്നാണ്. സൈഡ്കാർ അതിന്റെ സ്വന്തം പ്രോസസ് ഗ്രൂപ്പിൽ പ്രവർത്തിക്കുന്നു.
പേജിൽ നിന്നുള്ള അഭ്യർഥനകൾ
പേജ് neboFetch-ഉം ഒരു ആപേക്ഷിക പാത്തും ഉപയോഗിച്ച് നടത്തുന്ന /apps/<id>/api/<path>-ലേക്കുള്ള ഒരു അഭ്യർഥന, path <path> ആയി സജ്ജമാക്കി HandleRequest-ൽ എത്തുന്നു. _-ൽ തുടങ്ങുന്ന പാത്തുകൾ നിരസിക്കും. അഭ്യർഥനകളുടെ ബോഡി 10 MB-യായും മറുപടികൾ 32 MB-യായും പരിമിതപ്പെടുത്തിയിരിക്കുന്നു.
ജീവനക്കാരനുള്ള ടൂളുകൾ
ആപ്പിന്റെ agent.json-ൽ ടൂളുകൾ പ്രഖ്യാപിക്കൂ. ഓരോന്നും app__<app>__<name> എന്ന് പേരുള്ള ഒരു ടൂളായി മാറുന്നു, ജീവനക്കാരന് ആവശ്യമുള്ളപ്പോൾ ലോഡ് ചെയ്യുന്നു. ഒരു കോൾ method, path എന്നിവയിൽ സൈഡ്കാറിലേക്കുള്ള ഒരു അഭ്യർഥനയാകുന്നു.
"tools": [
{
"name": "list_deals",
"description": "List open deals, optionally filtered by stage.",
"method": "GET",
"path": "/deals",
"input_schema": { "type": "object", "properties": { "stage": { "type": "string" } } }
}
] Nebo-യെ വിളിക്കൽ
Authorization: Bearer $NEBO_APP_TOKEN ഹെഡറോടെ $NEBO_API_URL/api/v1/apps/$NEBO_APP_ID/... വിളിച്ച് സൈഡ്കാറിന് പേജിന്റെ അതേ സേവനങ്ങൾ ഉപയോഗിക്കാം.
| റൂട്ട് | ചെയ്യുന്നത് |
|---|---|
GET /storage, GET|PUT|DELETE /storage/<key> | ആപ്പിന്റെ key-value സ്റ്റോർ. |
POST /agents/invoke, POST /agents/stream | ഒരു ജീവനക്കാരനോട് ചോദിക്കുന്നു: {message, agent, data}. സ്ട്രീം മറുപടികൾ server-sent events ആണ്. |
POST /janus/complete, POST /janus/stream | നേരിട്ടുള്ള ഒരു മോഡൽ കോൾ: {messages, model, temperature, max_tokens, system}. |
POST /http/proxy | ആപ്പിന്റെ network: അനുമതികൾ അനുവദിക്കുന്ന ഒരു ബാഹ്യ അഭ്യർഥന, {url, method, headers, body}. |
GET /identity | ആപ്പിന്റെ ജീവനക്കാരൻ. |
ലൈഫ്സൈക്കിൾ
- Nebo ഓരോ മൂന്ന് സെക്കൻഡിലും സോക്കറ്റ് പരിശോധിക്കുന്നു.
- പരാജയപ്പെട്ട ഒരു സൈഡ്കാർ ഒരു സെക്കൻഡിനു ശേഷം പുനരാരംഭിക്കുന്നു, പരമാവധി 60 സെക്കൻഡ് വരെ ഇരട്ടിച്ചുകൊണ്ട്. തുടർച്ചയായ അഞ്ച് പരാജയങ്ങൾക്കു ശേഷം അത് പരാജയപ്പെട്ടതായി അടയാളപ്പെടുത്തും. 60 സെക്കൻഡ് പ്രവർത്തിച്ചുനിൽക്കുന്ന സൈഡ്കാർ വീണ്ടും ആരോഗ്യകരമാകും.
- നിർത്തിയ ഒരു സൈഡ്കാറിലേക്കുള്ള അഭ്യർഥന അതിനെ ആരംഭിക്കുകയും 15 സെക്കൻഡ് വരെ കാത്തിരിക്കുകയും ചെയ്യും. GET, HEAD അഭ്യർഥനകൾ വീണ്ടും ശ്രമിക്കും.
- ഒരു സൈഡ്കാർ നിർത്താൻ, Nebo അതിന്റെ പ്രോസസ് ഗ്രൂപ്പിലേക്ക് SIGTERM അയയ്ക്കുന്നു, എന്നിട്ട് രണ്ട് സെക്കൻഡിനു ശേഷം അതിനെ ബലമായി അവസാനിപ്പിക്കുന്നു.