Something went wrong. Try again.
small gleam coding and (not yet) persistent agent daemon with a detachable cli forked from okami.mom/albedo
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536package acp
import ( "bufio" "context" "crypto/rand" "encoding/base64" "encoding/json" "errors" "fmt" "io" "slices" "sync" "time"
"albedo/cli/internal/app" "albedo/cli/internal/daemon" "albedo/cli/internal/daemon/protocol")
type Backend interface { Catalog(context.Context) (app.ACPSettings, error) Refresh(context.Context, string, app.ACPSettings) (app.ACPSettings, error) Settings(context.Context, string) (app.ACPSettings, error) SetModel(context.Context, string, string) error SetEffort(context.Context, string, string) error SetContextWindow(context.Context, string, *int) error SetCompactionStrategy(context.Context, string, *string) error Compact(context.Context, string) (daemon.CompactionResult, error) Delete(context.Context, string) error List(context.Context, *string, *string) (protocol.SessionPage, error) History(context.Context, string, daemon.ACPHistoryCursor, int64) ([]daemon.StreamEvent, daemon.ACPHistoryCursor, error) Cancel(context.Context, string, string) (protocol.InputCancellation, error) New(context.Context, string, []protocol.ACPMCPServer) (protocol.ACPAttachment, error) Resume(context.Context, string, string, []protocol.ACPMCPServer) (protocol.ACPAttachment, error) Prepare(string, []json.RawMessage) (*daemon.OperationHandle, error) Submit(context.Context, *daemon.OperationHandle) error Renew(context.Context, string) error Release(context.Context, string) error Observer(string, protocol.Cursor) *daemon.ChatClient}
type Connector func(context.Context, string) (Backend, error)
func AppConnector(service *app.Service) Connector { return func(ctx context.Context, token string) (Backend, error) { return service.ConnectACP(ctx, token) }}
type adapter struct { backend Backend diagnostics io.Writer ctx context.Context cancel context.CancelFunc writer *writer connect Connector sessions map[string]*session attachmentTails map[string]chan struct{} token string watch streamFunc workers sync.WaitGroup setupMu sync.Mutex mu sync.Mutex capabilities clientCapabilities}
func Run(ctx context.Context, input io.Reader, output, diagnostics io.Writer, version string, connect Connector) error { ctx, cancel := context.WithCancel(ctx) defer cancel() token := make([]byte, 32) if _, err := rand.Read(token); err != nil { return err } adapter := &adapter{ctx: ctx, cancel: cancel, writer: newWriter(output), connect: connect, token: base64.RawURLEncoding.EncodeToString(token), sessions: map[string]*session{}, diagnostics: diagnostics} go adapter.writer.run(ctx) lines := make(chan []byte) readDone := make(chan error, 1) go func() { scanner := bufio.NewScanner(input) scanner.Buffer(make([]byte, 4096), 100*1024*1024) for scanner.Scan() { line := slices.Clone(scanner.Bytes()) select { case lines <- line: case <-ctx.Done(): return } } readDone <- scanner.Err() }() defer adapter.release() for { select { case <-ctx.Done(): if failure := adapter.writer.failure(); failure != nil { return failure } return ctx.Err() case <-adapter.writer.done: if err := adapter.writer.failure(); err != nil { return err } return ctx.Err() case err := <-readDone: if err != nil { return err } barrier := adapter.writer.flush() select { case <-barrier: case <-adapter.writer.done: return adapter.writer.failure() case <-ctx.Done(): return ctx.Err() } return nil case line := <-lines: message, failure := parse(line) if failure != nil { if failure.Code == -32602 && message.ID == nil { continue } adapter.respond(message.ID, nil, failure) continue } adapter.handle(message, version) } }}
type requestRoute struct { run func(*adapter, request) worker bool ordered bool}
var requestRoutes = map[method]requestRoute{ methodAuthenticate: {run: refuseAuthentication}, methodList: {run: (*adapter).list, worker: true}, methodNew: {run: (*adapter).setup, worker: true}, methodResume: {run: (*adapter).setup, worker: true, ordered: true}, methodLoad: {run: (*adapter).setup, worker: true, ordered: true}, methodConfig: {run: (*adapter).setConfigOption, worker: true, ordered: true}, methodClose: {run: (*adapter).closeSession, worker: true, ordered: true}, methodDelete: {run: (*adapter).deleteSession, worker: true, ordered: true}, methodPrompt: {run: (*adapter).prompt},}
func refuseAuthentication(a *adapter, message request) { a.respond(message.ID, nil, invalidParams("No authentication methods are available"))}
func (a *adapter) handle(message request, version string) { switch { case message.Method == "": return case message.Method == methodInitialize: a.initialize(message, version) case message.Method == methodCancel && message.ID == nil: a.cancelNotification(message) case message.ID == nil: return default: route, known := requestRoutes[message.Method] if !known { a.respond(message.ID, nil, unknownMethod()) return } switch { case route.worker && route.ordered: // Reserve the session's place here, on the reader, so two ordered // requests keep arrival order instead of racing their workers. run := a.reserve(message, route.run) a.workers.Go(run) case route.worker: a.workers.Go(func() { route.run(a, message) }) default: route.run(a, message) } }}
func (a *adapter) initialize(message request, version string) { var params struct { ProtocolVersion *int `json:"protocolVersion"` } if json.Unmarshal(message.Params, ¶ms) != nil || params.ProtocolVersion == nil || *params.ProtocolVersion < 1 { a.respond(message.ID, nil, invalidParams("protocolVersion must be a positive integer")) return } a.mu.Lock() a.capabilities = decodeClientCapabilities(message.Params) a.mu.Unlock() if message.ID != nil { a.respond(message.ID, initialize(version), nil) }}
func (a *adapter) response(id json.RawMessage, result any, failure error) map[string]any { if id == nil { id = json.RawMessage("null") } message := map[string]any{"jsonrpc": "2.0", "id": id} if failure == nil { message["result"] = result return message } var rpc *rpcError if !errors.As(failure, &rpc) { rpc = internalError(failure.Error()) if api, ok := errors.AsType[*daemon.APIError](failure); ok { rpc = daemonProblem(api) } if _, ok := errors.AsType[*daemon.CompatibilityError](failure); ok { rpc = problem(-32603, "daemon_incompatible", "Run `albedo daemon --restart` in a terminal to enable ACP.") } } message["error"] = rpc return message}
func daemonProblem(api *daemon.APIError) *rpcError { switch api.Code { case "provider_missing", "provider_unconfigured": rpc := problem(-32000, "provider_missing", "No model provider is configured.") rpc.Data["instruction"] = "Run `albedo login` in a terminal, then try again." return rpc case "session_not_found", "not_found": return problem(-32002, "session_not_found", api.Message) case "daemon_incompatible": return problem(-32603, api.Code, api.Message) } if api.StatusCode >= 500 { return problem(-32603, api.Code, api.Message) } return problem(-32602, api.Code, api.Message)}
func (a *adapter) respond(id json.RawMessage, result any, failure error) { if _, err := a.writer.enqueue(a.response(id, result, failure), false); err != nil { a.cancel() }}
type newSessionResult struct { SessionID string `json:"sessionId,omitempty"` Options []option `json:"configOptions"`}
func (a *adapter) setup(message request) { params, refusal := parseSetup(message) if refusal != nil { a.respond(message.ID, nil, refusal) return } servers, refusal := decodeMCPServers(params.mcpServers) if refusal != nil { a.respond(message.ID, nil, refusal) return } if err := a.connectBackend(); err != nil { a.respond(message.ID, nil, err) return } catalog, err := a.backend.Catalog(a.ctx) if err != nil { a.respond(message.ID, nil, err) return } var attachment protocol.ACPAttachment var prior *session if message.Method == methodNew { attachment, err = a.backend.New(a.ctx, params.cwd, servers) } else { prior = a.pausePrior(params.sessionID) attachment, err = a.backend.Resume(a.ctx, params.sessionID, params.cwd, servers) if err != nil && prior != nil { prior.resumeObservation() } } if err != nil { a.respond(message.ID, nil, err) return } settings, err := a.backend.Refresh(a.ctx, attachment.SessionID, catalog) if err != nil { setupFailed(a.backend, prior, attachment.SessionID) a.respond(message.ID, nil, err) return } a.stopPrior(attachment.SessionID) current := newSession(a, attachment) current.settings = settings a.reportSettings(attachment.SessionID, settings) if message.Method == methodLoad { current.pauseObservation() for id := range current.boundaries { current.withheld[id] = true } } current.start() a.mu.Lock() current.compactionEnabled = a.capabilities.compaction a.sessions[attachment.SessionID] = current a.mu.Unlock() if message.Method == methodLoad { current.advertiseCommands() if err := current.load(message); err != nil { a.discard(current) a.respond(message.ID, nil, err) } return } result := newSessionResult{Options: configOptions(current.settings)} if message.Method == methodNew { result.SessionID = attachment.SessionID } a.respond(message.ID, result, nil) current.advertiseCommands()}
func setupFailed(backend Backend, prior *session, id string) { if prior != nil { prior.resumeObservation() return } ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() _ = backend.Release(ctx, id)}
func (a *adapter) discard(current *session) { current.stop() a.mu.Lock() if a.sessions[current.id] == current { delete(a.sessions, current.id) } a.mu.Unlock() ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() _ = a.backend.Release(ctx, current.id)}
func (a *adapter) prompt(message request) { var params struct { SessionID string `json:"sessionId"` Prompt []json.RawMessage `json:"prompt"` } if err := decodeParams(message.Params, ¶ms); err != nil { a.respond(message.ID, nil, invalidParams(err.Error())) return } blocks, err := translatePrompt(params.Prompt) if err != nil { a.respond(message.ID, nil, invalidParams(err.Error())) return } current := a.attached(params.SessionID) if current == nil { a.respond(message.ID, nil, noSession()) return } current.prompt(message, blocks)}
func (a *adapter) cancelNotification(message request) { var params struct { SessionID string `json:"sessionId"` } if decodeParams(message.Params, ¶ms) != nil { return } if current := a.attached(params.SessionID); current != nil { current.cancelPrompt() }}
func (a *adapter) closeSession(message request) { id, failure := a.sessionParam(message) if failure != nil { a.respond(message.ID, nil, failure) return } a.detach(id) ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() if err := a.backend.Release(ctx, id); err != nil { a.respond(message.ID, nil, err) return } a.respond(message.ID, struct{}{}, nil)}
func (a *adapter) deleteSession(message request) { id, failure := a.sessionParam(message) if failure != nil { a.respond(message.ID, nil, failure) return } // Delete first: a refused or partial delete must leave the editor's session // usable, so detaching is the last thing a successful delete does. if err := a.backend.Delete(a.ctx, id); err != nil { a.respond(message.ID, nil, err) return } a.detach(id) a.respond(message.ID, struct{}{}, nil)}
func (a *adapter) sessionParam(message request) (string, error) { var params struct { SessionID string `json:"sessionId"` } if decodeParams(message.Params, ¶ms) != nil || !fullSessionID(params.SessionID) { return "", invalidParams("A full session ID is required") } if err := a.connectBackend(); err != nil { return "", err } return params.SessionID, nil}
func (a *adapter) detach(id string) { a.mu.Lock() current := a.sessions[id] delete(a.sessions, id) a.mu.Unlock() if current == nil { return } current.mu.Lock() current.fail("The editor closed this session") current.stop() current.mu.Unlock()}
func (a *adapter) release() { a.cancel() a.workers.Wait() a.mu.Lock() defer a.mu.Unlock() ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) defer cancel() for id, current := range a.sessions { current.stop() _ = a.backend.Release(ctx, id) }}
func (a *adapter) reserve(message request, run func(*adapter, request)) func() { var params struct { SessionID string `json:"sessionId"` } _ = json.Unmarshal(message.Params, ¶ms) a.mu.Lock() if a.attachmentTails == nil { a.attachmentTails = map[string]chan struct{}{} } prior := a.attachmentTails[params.SessionID] done := make(chan struct{}) a.attachmentTails[params.SessionID] = done a.mu.Unlock() return func() { if prior != nil { <-prior } defer func() { a.mu.Lock() if a.attachmentTails[params.SessionID] == done { delete(a.attachmentTails, params.SessionID) } close(done) a.mu.Unlock() }() run(a, message) }}
func (a *adapter) connectBackend() error { a.setupMu.Lock() defer a.setupMu.Unlock() if a.backend != nil { return nil } backend, err := a.connect(a.ctx, a.token) if err != nil { return err } a.backend = backend return nil}
// reportSettings says why a selector may be shorter than expected: a provider// catalogue that could not be read, or a model with no reasoning levels.func (a *adapter) reportSettings(id string, settings app.ACPSettings) { for _, note := range settings.Notes { a.note("session %s: %s", id, note) } if settings.Model != "" && len(settings.EffortLevels()) == 0 { a.note("session %s: model %s reports no reasoning levels", id, settings.Model) }}
func (a *adapter) note(format string, args ...any) { if a.diagnostics == nil { return } fmt.Fprintf(a.diagnostics, "acp: "+format+"\n", args...)}
func (a *adapter) attached(id string) *session { a.mu.Lock() defer a.mu.Unlock() return a.sessions[id]}
func (a *adapter) stopPrior(id string) { a.mu.Lock() prior := a.sessions[id] delete(a.sessions, id) a.mu.Unlock() if prior != nil { prior.mu.Lock() prior.fail("Attachment resumed by this connection") prior.stop() prior.mu.Unlock() }}
func (a *adapter) pausePrior(id string) *session { prior := a.attached(id) if prior != nil { prior.pauseObservation() } return prior}