Files
archie/modules/governance/governance.go
T
samandCopilot 64dfad6d53 feat(runs): add typed results and model aliases (#2043)
Also fix repository-free message.send validation (#2046) and add a single-binary development smoke path (#1977).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-18 23:47:35 +11:00

656 lines
24 KiB
Go

// Package governance owns an organisation's settings. So far that is the
// agent model: the provider class, base URL and model every agent loop uses.
// Nothing an event or a tool result says can change where a model request
// goes, because the client is built only from these settings.
package governance
import (
"context"
"encoding/json/jsontext"
json "encoding/json/v2"
"errors"
"fmt"
"log/slog"
"net/http"
"net/url"
"regexp"
"slices"
"strings"
"time"
"github.com/danielgtaylor/huma/v2"
"github.com/jmoiron/sqlx"
"github.com/samcharles93/ai-sdk/chat"
"github.com/samcharles93/ai-sdk/runtime"
"github.com/samcharles93/archie-core/internal/platform/httpapi"
"github.com/samcharles93/archie-core/modules/governance/internal/store"
)
// ErrNoAgentModel means the organisation hasn't chosen its agent model. There
// is no built-in default.
var ErrNoAgentModel = errors.New("no agent model is set for the organisation")
const (
roleAgent = "agent"
agentAliasPrefix = "agent:"
)
var agentAliasPattern = regexp.MustCompile(`^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,62}$`)
// ValidateAgentModelAlias accepts an empty alias for the default model.
func ValidateAgentModelAlias(alias string) error {
if alias != "" && !agentAliasPattern.MatchString(alias) {
return fmt.Errorf("invalid agent model alias %q: use 1-63 letters, digits, dots, underscores or hyphens, starting with a letter or digit", alias)
}
return nil
}
func agentModelRole(alias string) string {
if alias == "" || alias == "default" {
return roleAgent
}
return agentAliasPrefix + alias
}
// DefaultApprovalDeadline is how long an approval request waits for an answer
// when the organisation hasn't said.
const DefaultApprovalDeadline = 24 * time.Hour
// DefaultRaiseAfter is how many approvals in a row earn a proposal to raise an
// action class when the organisation hasn't said.
const DefaultRaiseAfter = 3
// maxRaiseAfter bounds the count: past it a class could never earn a raise.
const maxRaiseAfter = 100
// DefaultRecurrenceThreshold is how many incidents with one cause on one target
// it takes to propose a root-cause fix when the organisation hasn't said.
const DefaultRecurrenceThreshold = 5
// The bounds on the recurrence threshold. One incident is no pattern; past a
// hundred the history Archie keeps per target can't confirm it.
const (
minRecurrenceThreshold = 2
maxRecurrenceThreshold = 100
)
// DefaultAttemptsPerRun is how many steps an agent may take in one run when the
// organisation hasn't said.
const DefaultAttemptsPerRun = 20
// The bounds on attempts per run. An agent needs a few steps to look anything
// up; past two hundred a run is looping.
const (
minAttemptsPerRun = 2
maxAttemptsPerRun = 200
)
// The defaults and bounds on the action budgets.
const (
DefaultActionsPerRun = 10
DefaultActionsPerDay = 100
maxActionBudget = 10000
)
// The bounds on an approval deadline. Below a minute nobody could answer; past
// a month the request outlives the incident it was raised for.
const (
minApprovalDeadline = time.Minute
maxApprovalDeadline = 30 * 24 * time.Hour
)
// Settings is what the organisation decides about how Archie acts.
type Settings struct {
// ApprovalDeadline is how long an approval request waits for an answer
// before the run gives up on it.
ApprovalDeadline time.Duration
// RaiseAfter is how many approvals in a row, since an action class was last
// tightened, earn a proposal to raise it one level.
RaiseAfter int
// Frozen holds every action that changes something at propose and wait,
// without changing any class's level.
Frozen bool
// RecurrenceThreshold is how many incidents with the same cause on one
// target it takes, whatever their outcomes, to propose a root-cause fix.
RecurrenceThreshold int
// AttemptsPerRun is how many steps an agent may take in one run.
AttemptsPerRun int
// DefaultOwner is the id of the person who answers for what has no other
// owner, or empty.
DefaultOwner string
// Escalation is the people an unanswered request moves through, in order,
// each with how long the request waits on them.
Escalation []Step
// Timing is when changing actions may run without asking.
Timing Timing
// ActionsPerRun and ActionsPerDay are how many actions one run, and the
// organisation in a day, may take before a changing action waits for approval.
ActionsPerRun int
ActionsPerDay int
}
// Step is one stop on the escalation path: a person and how long an unanswered
// request waits on them before it moves to the next.
type Step struct {
// Person is the id of the person the request is passed to.
Person string
Deadline time.Duration
}
// stepRow is a step as stored.
type stepRow struct {
Person string `json:"person"`
DeadlineMS int64 `json:"deadline_ms"`
}
// stepRequest is a step as the API shows and sets it. Its deadline travels as
// a Go duration string, like the approval deadline.
type stepRequest struct {
Person string `json:"person"`
Deadline string `json:"deadline"`
}
// settingsRequest is the settings as the API shows and sets them. A duration
// travels as a Go duration string ("24h"), the same form every other duration
// in the config takes.
type settingsRequest struct {
ApprovalDeadline string `json:"approval_deadline"`
RaiseAfter int `json:"raise_after"`
Frozen bool `json:"frozen"`
RecurrenceThreshold int `json:"recurrence_threshold"`
AttemptsPerRun int `json:"attempts_per_run"`
DefaultOwner string `json:"default_owner"`
Escalation []stepRequest `json:"escalation"`
Timing Timing `json:"timing"`
ActionsPerRun int `json:"actions_per_run"`
ActionsPerDay int `json:"actions_per_day"`
}
func (s Settings) request() settingsRequest {
return settingsRequest{
ApprovalDeadline: s.ApprovalDeadline.String(), RaiseAfter: s.RaiseAfter, Frozen: s.Frozen,
RecurrenceThreshold: s.RecurrenceThreshold, AttemptsPerRun: s.AttemptsPerRun,
DefaultOwner: s.DefaultOwner, Escalation: stepRequests(s.Escalation),
Timing: s.Timing, ActionsPerRun: s.ActionsPerRun, ActionsPerDay: s.ActionsPerDay,
}
}
func stepRequests(steps []Step) []stepRequest {
out := make([]stepRequest, 0, len(steps))
for _, st := range steps {
out = append(out, stepRequest{Person: st.Person, Deadline: st.Deadline.String()})
}
return out
}
// stepsOf reads the steps of a request, each with a deadline inside the range
// an answer can be given in.
func stepsOf(req []stepRequest) ([]Step, error) {
out := make([]Step, 0, len(req))
for _, r := range req {
d, err := time.ParseDuration(r.Deadline)
if err != nil {
return nil, errors.New("each escalation deadline is a duration, such as 4h")
}
out = append(out, Step{Person: r.Person, Deadline: d})
}
return out, nil
}
// Model is the model chosen for a role.
type Model struct {
Class string `json:"class"`
BaseURL string `json:"base_url"`
Model string `json:"model"`
// APIKeyCredential names the credential whose token authenticates the
// provider. The dashboard shows the name, never the token.
APIKeyCredential string `json:"api_key_credential,omitempty"`
}
// Credentials resolves a credential's token by name. It is the connectors
// module's sealed store, so governance never holds a secret.
type Credentials interface {
BearerToken(ctx context.Context, credential string) (string, error)
}
// AgentProvider builds the chat client for model, resolving the credential it
// names whenever a run rebuilds the client.
func (m *Module) AgentProvider(ctx context.Context, model Model) (chat.Provider, chat.ModelInfo, error) {
return m.provider(ctx, model)
}
// provider builds the chat client for model, resolving its credential when it
// names one.
func (m *Module) provider(ctx context.Context, model Model) (chat.Provider, chat.ModelInfo, error) {
auth := runtime.AuthConfig{Type: runtime.AuthTypeNone}
if model.APIKeyCredential != "" {
if m.credentials == nil {
return nil, chat.ModelInfo{}, errors.New("no credential store is configured")
}
key, err := m.credentials.BearerToken(ctx, model.APIKeyCredential)
if err != nil {
return nil, chat.ModelInfo{}, fmt.Errorf("agent model credential %q: %w", model.APIKeyCredential, err)
}
auth = runtime.AuthConfig{Type: runtime.AuthTypeAPIKey, APIKey: key}
}
rt := runtime.NewRuntime(runtime.Config{Providers: map[string]runtime.ProviderConfig{
roleAgent: {ID: roleAgent, Class: model.Class, BaseURL: model.BaseURL, Auth: auth},
}})
ref := roleAgent + "/" + model.Model
provider, _, err := rt.ChatProvider(ctx, ref)
if err != nil {
return nil, chat.ModelInfo{}, fmt.Errorf("agent model %s: %w", ref, err)
}
info, err := rt.ChatModelInfo(ref)
if err != nil {
return nil, chat.ModelInfo{}, fmt.Errorf("agent model %s: %w", ref, err)
}
return provider, info, nil
}
// Module serves one organisation's settings.
type Module struct {
orgID string
store *store.Store
log *slog.Logger
credentials Credentials
}
// NewModule returns the governance module for orgID. The ai-sdk provider
// classes must already be registered.
func NewModule(db *sqlx.DB, log *slog.Logger, orgID string) *Module {
return &Module{orgID: orgID, store: store.New(db), log: log}
}
// UseCredentials gives the module the sealed store a model's key reference
// resolves through.
func (m *Module) UseCredentials(c Credentials) { m.credentials = c }
// AgentModel returns the organisation's agent model.
func (m *Module) AgentModel(ctx context.Context) (Model, error) {
return m.AgentModelForAlias(ctx, "")
}
// AgentModelForAlias resolves a model without falling back for unknown aliases.
func (m *Module) AgentModelForAlias(ctx context.Context, alias string) (Model, error) {
if err := ValidateAgentModelAlias(alias); err != nil {
return Model{}, err
}
key := agentModelRole(alias)
role, ok, err := m.store.ModelRole(ctx, m.orgID, key)
if err != nil {
return Model{}, err
}
if !ok {
if key != roleAgent {
return Model{}, fmt.Errorf("agent model alias %q: %w", alias, ErrNoAgentModel)
}
return Model{}, ErrNoAgentModel
}
return Model{Class: role.Class, BaseURL: role.BaseURL, Model: role.Model, APIKeyCredential: role.APIKeyCredential}, nil
}
// Settings returns the organisation's settings, with a default for every one it
// hasn't set.
func (m *Module) Settings(ctx context.Context) (Settings, error) {
row, ok, err := m.store.Settings(ctx, m.orgID)
if err != nil {
return Settings{}, err
}
if !ok {
return Settings{
ApprovalDeadline: DefaultApprovalDeadline, RaiseAfter: DefaultRaiseAfter,
RecurrenceThreshold: DefaultRecurrenceThreshold, AttemptsPerRun: DefaultAttemptsPerRun,
Escalation: []Step{}, Timing: Timing{}.normalised(),
ActionsPerRun: DefaultActionsPerRun, ActionsPerDay: DefaultActionsPerDay,
}, nil
}
var rows []stepRow
if err := json.Unmarshal(jsontext.Value(row.Escalation), &rows); err != nil {
return Settings{}, fmt.Errorf("read escalation path: %w", err)
}
escalation := make([]Step, 0, len(rows))
for _, r := range rows {
escalation = append(escalation, Step{Person: r.Person, Deadline: time.Duration(r.DeadlineMS) * time.Millisecond})
}
var timing Timing
if err := json.Unmarshal(jsontext.Value(row.Timing), &timing); err != nil {
return Settings{}, fmt.Errorf("read timing: %w", err)
}
return Settings{
Timing: timing.normalised(), ActionsPerRun: row.ActionsPerRun, ActionsPerDay: row.ActionsPerDay,
ApprovalDeadline: time.Duration(row.ApprovalDeadlineMS) * time.Millisecond,
RaiseAfter: row.RaiseAfter,
Frozen: row.Frozen,
RecurrenceThreshold: row.RecurrenceThreshold,
AttemptsPerRun: row.AttemptsPerRun,
DefaultOwner: row.DefaultOwner,
Escalation: escalation,
}, nil
}
// RaiseAfter is how many approvals in a row earn a proposal to raise an action
// class.
func (m *Module) RaiseAfter(ctx context.Context) (int, error) {
set, err := m.Settings(ctx)
if err != nil {
return 0, err
}
return set.RaiseAfter, nil
}
// Frozen reports whether the organisation has frozen its actions.
func (m *Module) Frozen(ctx context.Context) (bool, error) {
set, err := m.Settings(ctx)
if err != nil {
return false, err
}
return set.Frozen, nil
}
// RecurrenceThreshold is how many incidents with one cause on one target it
// takes to propose a root-cause fix.
func (m *Module) RecurrenceThreshold(ctx context.Context) (int, error) {
set, err := m.Settings(ctx)
if err != nil {
return 0, err
}
return set.RecurrenceThreshold, nil
}
// AttemptsPerRun is how many steps an agent may take in one run.
func (m *Module) AttemptsPerRun(ctx context.Context) (int, error) {
set, err := m.Settings(ctx)
if err != nil {
return 0, err
}
return set.AttemptsPerRun, nil
}
// ApprovalDeadline is how long an approval request waits for an answer.
func (m *Module) ApprovalDeadline(ctx context.Context) (time.Duration, error) {
set, err := m.Settings(ctx)
if err != nil {
return 0, err
}
return set.ApprovalDeadline, nil
}
// Register adds the settings API: organisation settings, the agent model and
// people.
func (m *Module) Register(api huma.API) {
tags := []string{"Governance"}
huma.Register(api, huma.Operation{
OperationID: "get-settings", Method: http.MethodGet, Path: "/api/settings",
Summary: "Get the organisation settings", Tags: tags,
}, m.getSettings)
huma.Register(api, huma.Operation{
OperationID: "put-settings", Method: http.MethodPut, Path: "/api/settings",
Summary: "Change the organisation settings", Tags: tags,
}, m.putSettings)
huma.Register(api, huma.Operation{
OperationID: "list-agent-models", Method: http.MethodGet, Path: "/api/settings/agent-models",
Summary: "List agent models by alias", Tags: tags,
}, m.listAgentModels)
huma.Register(api, huma.Operation{
OperationID: "get-agent-model", Method: http.MethodGet, Path: "/api/settings/agent-model",
Summary: "Get the agent model", Tags: tags,
}, m.getAgentModel)
huma.Register(api, huma.Operation{
OperationID: "put-agent-model", Method: http.MethodPut, Path: "/api/settings/agent-model",
Summary: "Set the agent model", Tags: tags,
}, m.putAgentModel)
huma.Register(api, huma.Operation{
OperationID: "test-agent-model", Method: http.MethodPost, Path: "/api/settings/agent-model/test",
Summary: "Ask a model one question before saving it", Tags: tags,
}, m.testAgentModel)
huma.Register(api, huma.Operation{
OperationID: "list-people", Method: http.MethodGet, Path: "/api/people",
Summary: "List the people", Tags: tags,
}, m.getPeople)
huma.Register(api, huma.Operation{
OperationID: "put-people", Method: http.MethodPut, Path: "/api/people",
Summary: "Replace the people", Tags: tags,
}, m.putPeople)
}
func (m *Module) getSettings(ctx context.Context, _ *struct{}) (*httpapi.Reply[settingsRequest], error) {
set, err := m.Settings(ctx)
if err != nil {
m.log.ErrorContext(ctx, "read settings", "error", err)
return nil, huma.NewError(http.StatusInternalServerError, "couldn't read the settings")
}
return httpapi.OK(set.request()), nil
}
func (m *Module) putSettings(ctx context.Context, in *struct{ Body settingsRequest }) (*httpapi.Reply[settingsRequest], error) {
req := in.Body
deadline, err := time.ParseDuration(req.ApprovalDeadline)
if err != nil {
return nil, huma.NewError(http.StatusBadRequest, "approval deadline is a duration, such as 24h")
}
steps, err := stepsOf(req.Escalation)
if err != nil {
return nil, huma.NewError(http.StatusBadRequest, err.Error())
}
set := Settings{
ApprovalDeadline: deadline, RaiseAfter: req.RaiseAfter, Frozen: req.Frozen,
RecurrenceThreshold: req.RecurrenceThreshold, AttemptsPerRun: req.AttemptsPerRun,
DefaultOwner: req.DefaultOwner, Escalation: steps,
Timing: req.Timing.normalised(), ActionsPerRun: req.ActionsPerRun, ActionsPerDay: req.ActionsPerDay,
}
if err := set.validate(); err != nil {
return nil, huma.NewError(http.StatusBadRequest, err.Error())
}
people, err := m.store.People(ctx, m.orgID)
if err != nil {
m.log.ErrorContext(ctx, "read people", "error", err)
return nil, huma.NewError(http.StatusInternalServerError, "couldn't save the settings")
}
if err := set.knows(people); err != nil {
return nil, huma.NewError(http.StatusBadRequest, err.Error())
}
rows := make([]stepRow, 0, len(set.Escalation))
for _, st := range set.Escalation {
rows = append(rows, stepRow{Person: st.Person, DeadlineMS: st.Deadline.Milliseconds()})
}
escalation, err := json.Marshal(rows)
if err != nil {
return nil, huma.NewError(http.StatusInternalServerError, "couldn't save the settings")
}
timing, err := json.Marshal(set.Timing)
if err != nil {
return nil, huma.NewError(http.StatusInternalServerError, "couldn't save the settings")
}
if err := m.store.PutSettings(ctx, store.Settings{
OrgID: m.orgID, ApprovalDeadlineMS: set.ApprovalDeadline.Milliseconds(),
RaiseAfter: set.RaiseAfter, Frozen: set.Frozen, RecurrenceThreshold: set.RecurrenceThreshold,
AttemptsPerRun: set.AttemptsPerRun, DefaultOwner: set.DefaultOwner, Escalation: string(escalation),
Timing: string(timing), ActionsPerRun: set.ActionsPerRun, ActionsPerDay: set.ActionsPerDay,
}); err != nil {
m.log.ErrorContext(ctx, "put settings", "error", err)
return nil, huma.NewError(http.StatusInternalServerError, "couldn't save the settings")
}
return httpapi.OK(set.request()), nil
}
// validate keeps a deadline inside the range an answer can be given in, the
// count of approvals a raise needs inside the range a class can earn, and the
// recurrence threshold inside the range that means a pattern.
func (s Settings) validate() error {
if s.RecurrenceThreshold < minRecurrenceThreshold || s.RecurrenceThreshold > maxRecurrenceThreshold {
return fmt.Errorf("recurrence threshold must be between %d and %d", minRecurrenceThreshold, maxRecurrenceThreshold)
}
if s.ApprovalDeadline < minApprovalDeadline || s.ApprovalDeadline > maxApprovalDeadline {
return fmt.Errorf("approval deadline must be between %s and %s", minApprovalDeadline, maxApprovalDeadline)
}
if s.RaiseAfter < 1 || s.RaiseAfter > maxRaiseAfter {
return fmt.Errorf("raise after must be between 1 and %d approvals", maxRaiseAfter)
}
if s.AttemptsPerRun < minAttemptsPerRun || s.AttemptsPerRun > maxAttemptsPerRun {
return fmt.Errorf("attempts per run must be between %d and %d", minAttemptsPerRun, maxAttemptsPerRun)
}
if err := validDeadlines(s.Escalation); err != nil {
return err
}
if s.ActionsPerRun < 1 || s.ActionsPerRun > maxActionBudget || s.ActionsPerDay < s.ActionsPerRun || s.ActionsPerDay > maxActionBudget {
return fmt.Errorf("actions per run must be at least 1, and actions per day at least that and at most %d", maxActionBudget)
}
return s.Timing.validate()
}
// validDeadlines keeps each escalation step's deadline inside the range the
// approval deadline takes.
func validDeadlines(path []Step) error {
for _, st := range path {
if st.Deadline < minApprovalDeadline || st.Deadline > maxApprovalDeadline {
return fmt.Errorf("each escalation deadline must be between %s and %s", minApprovalDeadline, maxApprovalDeadline)
}
}
return nil
}
// knows checks that the default owner and every person on the escalation path
// is one of people, and that no one is on the path twice.
func (s Settings) knows(people []store.Person) error {
known := func(id string) bool {
return slices.ContainsFunc(people, func(p store.Person) bool { return p.ID.String() == id })
}
if s.DefaultOwner != "" && !known(s.DefaultOwner) {
return errors.New("the default owner must be one of the people")
}
seen := map[string]bool{}
for _, st := range s.Escalation {
if !known(st.Person) {
return errors.New("everyone on the escalation path must be one of the people")
}
if seen[st.Person] {
return errors.New("a person can be on the escalation path once")
}
seen[st.Person] = true
}
return nil
}
func (m *Module) listAgentModels(ctx context.Context, _ *struct{}) (*httpapi.Reply[map[string]Model], error) {
rows, err := m.store.AgentModelRoles(ctx, m.orgID)
if err != nil {
m.log.ErrorContext(ctx, "list agent models", "error", err)
return nil, huma.NewError(http.StatusInternalServerError, "couldn't list agent models")
}
out := make(map[string]Model, len(rows))
for _, row := range rows {
alias := strings.TrimPrefix(row.Role, agentAliasPrefix)
if row.Role == roleAgent {
alias = "default"
}
out[alias] = Model{Class: row.Class, BaseURL: row.BaseURL, Model: row.Model, APIKeyCredential: row.APIKeyCredential}
}
return httpapi.OK(out), nil
}
type agentModelAlias struct {
Alias string `query:"alias" doc:"Agent model alias; omit for the default model"`
}
func (m *Module) getAgentModel(ctx context.Context, in *agentModelAlias) (*httpapi.Reply[Model], error) {
if err := ValidateAgentModelAlias(in.Alias); err != nil {
return nil, huma.NewError(http.StatusBadRequest, err.Error())
}
model, err := m.AgentModelForAlias(ctx, in.Alias)
switch {
case errors.Is(err, ErrNoAgentModel):
return nil, huma.NewError(http.StatusNotFound, err.Error())
case err != nil:
m.log.ErrorContext(ctx, "read agent model", "error", err)
return nil, huma.NewError(http.StatusInternalServerError, "couldn't read the agent model")
default:
return httpapi.OK(model), nil
}
}
type agentModelInput struct {
Alias string `query:"alias" doc:"Agent model alias; omit for the default model"`
Body Model
}
// putAgentModel stores the resolved base URL so saved settings are explicit.
func (m *Module) putAgentModel(ctx context.Context, in *agentModelInput) (*httpapi.Reply[Model], error) {
if err := ValidateAgentModelAlias(in.Alias); err != nil {
return nil, huma.NewError(http.StatusBadRequest, err.Error())
}
req := in.Body
model, err := settle(req)
if err != nil {
return nil, huma.NewError(http.StatusBadRequest, err.Error())
}
if _, _, err := m.provider(ctx, model); err != nil {
return nil, huma.NewError(http.StatusBadRequest, err.Error())
}
if err := m.store.PutModelRole(ctx, store.ModelRole{
OrgID: m.orgID, Role: agentModelRole(in.Alias), Class: model.Class, BaseURL: model.BaseURL, Model: model.Model,
APIKeyCredential: model.APIKeyCredential,
}); err != nil {
m.log.ErrorContext(ctx, "put agent model", "error", err)
return nil, huma.NewError(http.StatusInternalServerError, "couldn't save the agent model")
}
return httpapi.OK(model), nil
}
// modelAnswer is a test call's answer.
type modelAnswer struct {
Model string `json:"model"`
Answer string `json:"answer"`
}
// testTimeout bounds a test call, so a slow endpoint answers the operator with
// a failure instead of holding the request open.
const testTimeout = 60 * time.Second
// testAgentModel asks the model one question and reports its answer, so the
// operator knows the endpoint, model and key work before saving them.
func (m *Module) testAgentModel(ctx context.Context, in *struct{ Body Model }) (*httpapi.Reply[modelAnswer], error) {
req := in.Body
model, err := settle(req)
if err != nil {
return nil, huma.NewError(http.StatusBadRequest, err.Error())
}
provider, _, err := m.provider(ctx, model)
if err != nil {
return nil, huma.NewError(http.StatusBadRequest, err.Error())
}
ctx, cancel := context.WithTimeout(ctx, testTimeout)
defer cancel()
resp, err := provider.Chat(ctx, chat.Request{
Model: model.Model,
Messages: []chat.Message{{Role: chat.RoleUser, Content: "Reply with the single word OK."}},
MaxTokens: 32,
})
if err != nil {
return nil, huma.NewError(http.StatusBadGateway, err.Error())
}
return httpapi.OK(modelAnswer{Model: model.Model, Answer: resp.Content}), nil
}
func settle(req Model) (Model, error) {
if _, ok := runtime.GetClass(req.Class); !ok {
return Model{}, fmt.Errorf("unknown provider class %q", req.Class)
}
if req.Model == "" {
return Model{}, errors.New("a model is required")
}
if req.BaseURL == "" {
base, ok := runtime.DefaultBaseURL(req.Class)
if !ok {
return Model{}, fmt.Errorf("provider class %q has no default base URL; give one", req.Class)
}
req.BaseURL = base
}
u, err := url.Parse(req.BaseURL)
if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" {
return Model{}, fmt.Errorf("base URL %q must be an http or https URL", req.BaseURL)
}
return req, nil
}