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.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387package daemon
import ( "context" "fmt" "io" "net/http" "strconv" "strings"
"albedo/cli/internal/config" "albedo/cli/internal/daemon/protocol")
type Model struct { ID, Label, CapKey, CyberStatus, CyberDetail, DefaultEffort, DefaultEffortSource string Efforts, Input []string Context, MaxContext, Output int Raised bool // CompactAt is the tokens every session compacts this model at; zero // follows the model's window. CompactAt int}type EffortResult struct { Effort, Message, ETag, DefaultEffort, DefaultEffortSource string Available []string}type CompactAtResult struct { ContextWindow *int64 Message, ETag string}type ModelSelection struct{ Provider, Model, Protocol, Effort, ETag, DefaultETag, CyberAccess string }type ModelSelectionRequest struct { CyberAccess *string // nil leaves mode implicit; empty explicitly selects Standard. Model, Provider, Effort, ETag, AttachmentToken string}type ModelChangeRequest struct { CyberAccess *string Model, Provider, Effort, ETag, DefaultETag string MakeDefault bool}type ModelContextCapRequest struct { CapKey, ETag string Enabled bool}
// ModelCapsRequest changes what is saved for one model in one write: raise its// cap, set the window it compacts at, or clear that window with zero. A nil// field is left as it is.type ModelCapsRequest struct { CapKey, ETag string Raise *bool CompactAt *int}
// PatchSessionEffort changes only the saved reasoning choice for one session.// An ACP attachment token may authorize this model-scoped setting.func PatchSessionEffort(ctx context.Context, conn *Connection, id, effort, token string) (SessionConfiguration, error) { configuration, err := GetSessionConfiguration(ctx, conn, id) if err != nil { return SessionConfiguration{}, err } params := &protocol.PatchSessionParams{View: "configuration", IfMatch: configuration.ETag} if token != "" { params.AlbedoAttachmentToken = &token } body := map[string]any{"effort": effort} err = executeMutation(ctx, conn, operation{Name: "set session effort", BuildRequest: func(base string, body io.Reader) (*http.Request, error) { return protocol.NewPatchSessionRequestWithBody(base, protocol.ID(id), params, "application/merge-patch+json", body) }, Body: body, Policy: noRecovery}, []int{200}, func([]byte, int) error { return nil }) if err != nil { return SessionConfiguration{}, err } return GetSessionConfiguration(ctx, conn, id)}
// PatchSessionContextWindow changes only the session's compaction window; a nil// tokens restores the model's own window.func PatchSessionContextWindow(ctx context.Context, conn *Connection, id string, tokens *int, token string) (SessionConfiguration, error) { configuration, err := GetSessionConfiguration(ctx, conn, id) if err != nil { return SessionConfiguration{}, err } params := &protocol.PatchSessionParams{View: "configuration", IfMatch: configuration.ETag} if token != "" { params.AlbedoAttachmentToken = &token } // The pointer marshals to null when nil, and a null window is what restores // the model's own. body := map[string]any{"context_window": tokens} err = executeMutation(ctx, conn, operation{Name: "set session context window", BuildRequest: func(base string, body io.Reader) (*http.Request, error) { return protocol.NewPatchSessionRequestWithBody(base, protocol.ID(id), params, "application/merge-patch+json", body) }, Body: body, Policy: noRecovery}, []int{200}, func([]byte, int) error { return nil }) if err != nil { return SessionConfiguration{}, err } return GetSessionConfiguration(ctx, conn, id)}
func ListProfileModels(ctx context.Context, conn *Connection, profile config.Settings) ([]Model, error) { if profile.ProfileName != "" { return listModels(ctx, conn, protocol.ListModelsParams{ProviderProfile: &profile.ProfileName}) } return ListModels(ctx, conn, profile.Extension, profile.BaseURL)}
// ListSessionProfileModels binds capability metadata to this session's exact account.// Generic profile catalog results must never be used to offer a Blue action.func ListSessionProfileModels(ctx context.Context, conn *Connection, session, profile string) ([]Model, error) { if session == "" || profile == "" { return nil, fieldError("session model catalog scope") } return listModels(ctx, conn, protocol.ListModelsParams{Session: &session, ProviderProfile: &profile})}
type SessionModelMetadata struct { ProfileEffort string Model Model}
// ModelMetadata reads presentation and capability facts for this session's account.func (c *ChatClient) ModelMetadata(ctx context.Context, profile, id string) (SessionModelMetadata, error) { rows, err := listModels(ctx, c.conn, protocol.ListModelsParams{Session: &c.agentID, ProviderProfile: &profile, Model: &id}) if err != nil { return SessionModelMetadata{}, err } profiles, err := ProviderProfiles(ctx, c.conn) if err != nil { return SessionModelMetadata{}, err } profileEffort := "" if effort := profiles.Providers[profile].Effort; effort != nil { profileEffort = *effort } for _, model := range rows { if model.ID == id { return SessionModelMetadata{Model: model, ProfileEffort: profileEffort}, nil } } return SessionModelMetadata{}, fmt.Errorf("model %q has no metadata", id)}func ListModels(ctx context.Context, conn *Connection, provider, endpoint string) ([]Model, error) { params := protocol.ListModelsParams{Provider: &provider} if endpoint != "" { params.Endpoint = &endpoint } return listModels(ctx, conn, params)}func listModels(ctx context.Context, conn *Connection, params protocol.ListModelsParams) ([]Model, error) { result := []Model{} params.Limit = new(int64(200)) err := walkPages(func(next *string) (protocol.ModelPage, *string, error) { params.Next = next var page protocol.ModelPage pageErr := executeRead(ctx, conn, operation{Name: "list models", BuildRequest: func(base string, body io.Reader) (*http.Request, error) { return protocol.NewListModelsRequest(base, ¶ms) }, Policy: readRecovery}, func(data []byte) error { return decodeRequired(data, &page) }) return page, page.Next, pageErr }, func(page protocol.ModelPage) error { if page.Items == nil { return fieldError("models") } for _, row := range page.Items { if row.ID == "" || row.CapKey == "" || row.Efforts == nil { return fieldError("model") } model := Model{DefaultEffortSource: value(row.DefaultEffortSource), DefaultEffort: value(row.DefaultEffort), ID: row.ID, Label: row.Label, CapKey: row.CapKey, Input: row.InputModalities, Context: int(value(row.DefaultContextTokens)), MaxContext: int(value(row.MaxContextTokens)), Output: int(value(row.MaxOutputTokens)), Raised: row.Raised, CompactAt: int(value(row.CompactAt))} if row.CyberAccess != nil { model.CyberStatus, model.CyberDetail = row.CyberAccess.Status, value(row.CyberAccess.Detail) } for _, effort := range row.Efforts { model.Efforts = append(model.Efforts, effort.ID) } result = append(result, model) } return nil }, "model page cursor") if err != nil { return nil, err } return result, nil}
func SelectModel(ctx context.Context, conn *Connection, id string, request ModelSelectionRequest) (ModelSelection, error) { body := map[string]any{} if request.Model != "" { body["model"] = request.Model } if request.CyberAccess != nil { body["cyber_access"] = optionalText(*request.CyberAccess) } if request.Provider != "" { body["provider_profile"] = request.Provider } if request.Effort != "" { body["effort"] = request.Effort } headers, err := observedHeaders(request.ETag) if err != nil { return ModelSelection{}, err } if request.AttachmentToken != "" { headers.Set("Albedo-Attachment-Token", request.AttachmentToken) } session, err := patchSessionWithHeaders(ctx, conn, id, headers, body) return ModelSelection{Provider: session.Provider, Model: session.Model, Protocol: session.Protocol, Effort: session.Effort, CyberAccess: session.CyberAccess, ETag: session.ETag}, err}func ChangeModel(ctx context.Context, conn *Connection, id string, request ModelChangeRequest) (ModelSelection, error) { if request.MakeDefault && request.DefaultETag == "" { return ModelSelection{}, fieldError("provider settings validator") } selection, err := SelectModel(ctx, conn, id, ModelSelectionRequest{Model: request.Model, Provider: request.Provider, Effort: request.Effort, ETag: request.ETag, CyberAccess: request.CyberAccess}) if err != nil { return selection, err } if request.MakeDefault { profileChange := map[string]any{"model": selection.Model} // Inherit follows the existing profile choice. Saving the model must // not turn that choice into a new reasoning override. if selection.Effort != "inherit" { profileChange["effort"] = optionalText(selection.Effort) } var change protocol.ProviderSettingsChange saveErr := patchSettingsGroup(ctx, conn, "providers", request.DefaultETag, map[string]any{"profiles": map[string]any{selection.Provider: profileChange}}, &change) selection.DefaultETag = change.Resource.ETag if saveErr != nil { return selection, fmt.Errorf("switched session; saving the default model: %w", saveErr) } } return selection, nil}func SetModelContextCap(ctx context.Context, conn *Connection, request ModelContextCapRequest) (string, error) { return SetModelCaps(ctx, conn, ModelCapsRequest{CapKey: request.CapKey, ETag: request.ETag, Raise: &request.Enabled})}
// SetModelCaps saves the changes in request and returns the settings' new ETag.func SetModelCaps(ctx context.Context, conn *Connection, request ModelCapsRequest) (string, error) { if request.CapKey == "" { return "", fieldError("model cap key") } patch := map[string]any{} if request.Raise != nil { patch["raised_caps"] = map[string]bool{request.CapKey: *request.Raise} } if request.CompactAt != nil { patch["compact_at"] = map[string]any{request.CapKey: optionalWindow(*request.CompactAt)} } var change protocol.ModelSettingsChange err := patchSettingsGroup(ctx, conn, "models", request.ETag, patch, &change) return change.Resource.ETag, err}
// optionalWindow is a window for the settings patch, null for none.func optionalWindow(tokens int) any { if tokens == 0 { return nil } return tokens}func ReadEffort(ctx context.Context, conn *Connection, session Session) (EffortResult, error) { params := protocol.ListModelsParams{Model: &session.Model} if session.Provider != "" { params.ProviderProfile = &session.Provider } models, err := listModels(ctx, conn, params) if err != nil { return EffortResult{}, err } for _, model := range models { if model.ID == session.Model { return EffortResult{Effort: session.Effort, DefaultEffort: model.DefaultEffort, DefaultEffortSource: model.DefaultEffortSource, Available: model.Efforts}, nil } } return EffortResult{}, fmt.Errorf("model %q has no metadata", session.Model)}
// SelectEffort clears the preference when effort is empty.func SelectEffort(ctx context.Context, conn *Connection, session Session, effort string) (EffortResult, error) { result, err := patchSession(ctx, conn, session.ID, session.ETag, map[string]any{"effort": optionalText(effort)}) return EffortResult{Effort: result.Effort, Message: "Effort saved.", ETag: result.ETag}, err}
// maxContextWindow is the daemon's ceiling on a session window (context_limits.is_window).const maxContextWindow = 100_000_000
// ParseTokenWindow parses a positive token count such as 100k, 1.5m, or 250000.func ParseTokenWindow(raw string) (int64, error) { cleaned := strings.ToLower(strings.TrimSpace(raw)) cleaned = strings.ReplaceAll(strings.ReplaceAll(cleaned, "_", ""), ",", "") multiplier := int64(1) switch { case strings.HasSuffix(cleaned, "k"): cleaned = strings.TrimSuffix(cleaned, "k") multiplier = 1000 case strings.HasSuffix(cleaned, "m"): cleaned = strings.TrimSuffix(cleaned, "m") multiplier = 1_000_000 } var tokens int64 if wholeStr, fracStr, hasDot := strings.Cut(cleaned, "."); hasDot { if multiplier == 1 || wholeStr == "" || fracStr == "" { return 0, fmt.Errorf("expected a positive token count such as 100k, 250000, or 1m, not %s", raw) } whole, err := strconv.ParseInt(wholeStr, 10, 64) if err != nil || whole < 0 { return 0, fmt.Errorf("expected a positive token count such as 100k, 250000, or 1m, not %s", raw) } frac, err := strconv.ParseInt(fracStr, 10, 64) if err != nil || frac < 0 { return 0, fmt.Errorf("expected a positive token count such as 100k, 250000, or 1m, not %s", raw) } scale := int64(1) for range len(fracStr) { scale *= 10 } if scale > multiplier { return 0, fmt.Errorf("expected a positive token count such as 100k, 250000, or 1m, not %s", raw) } tokens = whole*multiplier + frac*(multiplier/scale) } else { whole, err := strconv.ParseInt(cleaned, 10, 64) if err != nil { return 0, fmt.Errorf("expected a positive token count such as 100k, 250000, or 1m, not %s", raw) } tokens = whole * multiplier } if tokens <= 0 || tokens > maxContextWindow { return 0, fmt.Errorf("expected a positive token count such as 100k, 250000, or 1m, not %s", raw) } return tokens, nil}
// ReadCompactAt reports the window the session compacts against, in the// daemon's words.func ReadCompactAt(ctx context.Context, conn *Connection, session Session) (CompactAtResult, error) { var window protocol.ContextWindow err := executeRead(ctx, conn, operation{Capability: "context", Name: "read context window", BuildRequest: func(base string, body io.Reader) (*http.Request, error) { return protocol.NewGetContextWindowRequest(base, session.ID) }, Policy: readRecovery}, func(data []byte) error { return decodeRequired(data, &window) }) if err != nil { return CompactAtResult{}, err } return CompactAtResult{ContextWindow: window.ContextWindow, Message: window.Message}, nil}
// SelectCompactAt sets or clears the session's context window override.func SelectCompactAt(ctx context.Context, conn *Connection, session Session, raw string) (CompactAtResult, error) { trimmed := strings.ToLower(strings.TrimSpace(raw)) var window *int64 if trimmed != "default" && trimmed != "reset" && trimmed != "off" { parsed, err := ParseTokenWindow(raw) if err != nil { return CompactAtResult{}, err } window = &parsed } result, err := SetContextWindow(ctx, conn, session.ID, session.ETag, window) if err != nil { return CompactAtResult{}, err } if window != nil { return CompactAtResult{ContextWindow: result.ContextWindow, Message: fmt.Sprintf("Context window for this session set to %d tokens.", *window), ETag: result.ETag}, nil } return CompactAtResult{ContextWindow: nil, Message: "Restored the model's default context window for this session.", ETag: result.ETag}, nil}
// ResolveSessionModel keeps a manual ID in the observed session profile, or// selects an explicitly named configured profile. The daemon validates the ID// and computes the available reasoning efforts.func ResolveSessionModel(profiles config.Profiles, requested string) (string, string, error) { if strings.TrimSpace(requested) == "" { return "", "", fmt.Errorf("enter a model ID") } for name := range profiles.Providers { if model, explicit := strings.CutPrefix(requested, name+"/"); explicit { if model == "" { return "", "", fmt.Errorf("enter a model ID after %s/", name) } return name, model, nil } } if _, configured := profiles.Providers[profiles.Active]; !configured { return "", "", fmt.Errorf("the session's provider is not configured; run /login") } return profiles.Active, requested, nil}