feelgen

type Attempt struct {
	Format string
	Fault  string
	// Error is the engine's verdict, or the reason the round produced nothing usable.
	// Empty for a round without a fault.
	Error string
	// Calls are the callees the check refused, by name — the foreign functions a
	// model reached for.
	Calls []string
}

type Capability struct {
	Available bool     `json:"available"`
	Workers   []Worker `json:"workers"`
}

type Check struct {
	// OK is true when the expression compiled, every call in it is one this build
	// can make (ADR-0388), and it evaluated. It says nothing about whether the result
	// is the right one; Matches does.
	OK bool `json:"ok"`
	// Result and Kind are the value as the FEEL evaluate route reports it: the
	// canonical text and its kind's label (expr.ValueKind.Label).
	Result string `json:"result,omitempty"`
	Kind   string `json:"kind,omitempty"`
	Error  string `json:"error,omitempty"`
	// Fault is the kind of failure when OK is false: FaultCompile, FaultCalls or
	// FaultEvaluate. Calls names the callees a FaultCalls refused; it is reported to
	// whoever measures the prompt (Outcome), not to the console, whose author reads
	// the same names in Error.
	Fault string   `json:"fault,omitempty"`
	Calls []string `json:"-"`
	// Inputs are the variables the expression reads, and Missing those of them the
	// example does not bind. A missing input reads as null, which makes the example
	// prove nothing about it.
	Inputs  []string `json:"inputs,omitempty"`
	Missing []string `json:"missing,omitempty"`
	// Expected is what the model said the expression returns, as JSON text, and
	// Matches whether the engine agrees. Both are absent when it said nothing.
	Expected string `json:"expected,omitempty"`
	Matches  *bool  `json:"matches,omitempty"`
}

type Outcome struct {
	Worker string
	// Model is the language model that was asked: the Worker's own, or the one the
	// request chose. Comparing models is the second thing the data is for.
	Model string
	// Prompt is the PromptVersion that was sent.
	Prompt   string
	Result   string
	Attempts []Attempt
	Duration time.Duration
}

type Proposal struct {
	Expression  string
	Explanation string
	// Variables is the model's example, decoded with exact numbers. Nil when it gave
	// none, or gave something that is not an object and so cannot bind by name.
	Variables map[string]any
	// Expected is what the model says the expression returns for Variables, and
	// HasExpected whether it said anything at all — "expected": null is a claim too.
	Expected    any
	HasExpected bool
	// Format is which reading of the answer succeeded: the contract, a code block, or
	// plain prose (FormatContract, FormatCodeBlock, FormatProse).
	Format string
}

type Request struct {
	// Messages is the conversation, oldest first. The last one is the author's and is
	// the one to answer.
	Messages []Turn `json:"messages"`
	// Expression is what the assistant's editor holds now, which the author may have
	// changed by hand since the last answer.
	Expression string `json:"expression,omitempty"`
	// Variables are the editor's test variables, a JSON object. They are shown to the
	// model and are what an answer without an example of its own is checked against.
	Variables json.RawMessage `json:"variables,omitempty"`
	// Target says where the expression will be used — the field the assistant was
	// opened from, in the console's words — because a gateway condition must be a
	// boolean and a decision table's input cell is not an expression at all.
	Target string `json:"target,omitempty"`
	// Worker names the agent Worker to ask; empty picks the only one in reach.
	Worker string `json:"worker,omitempty"`
	// Model overrides the language model that Worker is configured for (ADR-0256).
	Model string `json:"model,omitempty"`
}

type Response struct {
	Expression  string `json:"expression"`
	Explanation string `json:"explanation"`
	// Variables is the example the expression was checked against — the model's
	// own, or the author's when it gave none — for the console to load beside it.
	Variables json.RawMessage `json:"variables,omitempty"`
	// Check is the engine's verdict, absent when the answer was a question back.
	Check *Check `json:"check,omitempty"`
	// Reply is the model's turn as the console should keep it and send it back.
	Reply string `json:"reply"`
	// Attempts is how many times the model was asked: one, plus each correction.
	Attempts int `json:"attempts"`
	// Warning says why a correction round could not run, when one could not — the
	// proposal is then the best answer the model had given.
	Warning string `json:"warning,omitempty"`
	Worker  string `json:"worker"`
	Model   string `json:"model,omitempty"`
	// Prompt is the PromptVersion that asked: an author comparing two answers across
	// an upgrade can tell whether the prompt changed between them.
	Prompt string `json:"prompt"`
}

type Service struct {

	// Observe, when set, is told what every request that reached a model came to
	// (Outcome). The server logs it and counts it; nil measures nothing.
	Observe func(Outcome)

	// Limits are the installation's resource budgets. New sets them to
	// [limits.Default]; the server overwrites them with its own (ADR-0291).
	Limits limits.Limits
	// contains filtered or unexported fields
}

type Turn struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

type Worker struct {
	Name     string `json:"name"`
	Model    string `json:"model,omitempty"`
	Provider string `json:"provider,omitempty"`
}