package opencode import ( "context" "errors" "fmt" "strings" "time" "git.a-wan.net/alan/pipelines/internal/protocol" ) // catalogTTL bounds how long one /api/model read answers listed rows, so a // session list never reads the catalog once per row. const catalogTTL = time.Minute // modelCatalog is Models, cached for catalogTTL. func (c *Chat) modelCatalog(ctx context.Context) ([]protocol.ChatModel, error) { c.catalogMu.Lock() cached, at := c.catalog, c.catalogAt c.catalogMu.Unlock() if cached != nil && time.Since(at) < catalogTTL { return cached, nil } models, err := c.Models(ctx, "") if err != nil { return nil, err } c.catalogMu.Lock() c.catalog, c.catalogAt = models, time.Now() c.catalogMu.Unlock() return models, nil } // Efforts reports the variants the endpoint lists for the session's model. // OpenCode stores the chosen variant on the session's model itself (the row's // Effort); with none chosen it uses the model's base settings, so there is no // separate default level. The v1 API has no variants. func (c *Chat) Efforts(ctx context.Context, session protocol.ChatSession) ([]protocol.ChatEffort, string, error) { if c.conn == nil || c.conn.Backend == "v1" || session.Model == "" || session.ModelProvider == "" { return nil, "", nil } models, err := c.modelCatalog(ctx) if err != nil { return nil, "", err } for _, model := range models { if model.ID == session.Model && model.Provider == session.ModelProvider { return append([]protocol.ChatEffort(nil), model.Efforts...), "", nil } } return nil, "", nil } // SetEffort selects the variant on the session's current model with the // documented session model endpoint, which OpenCode persists with the session // and applies from the next turn. "" selects the model without a variant. func (c *Chat) SetEffort(ctx context.Context, id, effort string) error { if !sessionID.MatchString(id) { return fmt.Errorf("invalid OpenCode session id") } if c.conn == nil || c.conn.Backend == "v1" { return errors.New("this OpenCode endpoint has no model variants") } session, found, err := c.Session(ctx, id) if err != nil { return err } if !found || session.Model == "" || session.ModelProvider == "" { return errors.New("the OpenCode session has no model to set a thinking level on") } ref := map[string]string{"id": session.Model, "providerID": session.ModelProvider} if effort = strings.TrimSpace(effort); effort != "" { ref["variant"] = effort } if evidence, err := c.call(ctx, "post", "/api/session/"+id+"/model", map[string]any{"model": ref}); err != nil { if reason := strings.TrimSpace(string(evidence)); reason != "" { if len(reason) > 300 { reason = reason[:300] } return fmt.Errorf("%w: %s", err, reason) } return err } return nil }