ai

type CheckResult struct {
	Name   string `json:"name"`
	OK     bool   `json:"ok"`
	Detail string `json:"detail,omitempty"`
}

type Coverage struct {
	Endpoints []EndpointCoverage `json:"endpoints"`
	// Unmatched are requests that use no endpoint of the API.
	Unmatched []RequestRef `json:"unmatched,omitempty"`
	// Templated counts requests whose whole URL is an expression, which
	// cannot be matched statically.
	Templated int `json:"templated,omitempty"`
	Covered   int `json:"covered"`
	Total     int `json:"total"`
}

type Dependency struct {
	Producer string `json:"producer"` // "POST /api/login"
	Value    string `json:"value"`    // "$.token", "cookie session", "header Location"
	Consumer string `json:"consumer"` // "GET /api/me"
	Via      string `json:"via"`      // "Authorization: Bearer", "path {id}", "json productId"
	Kind     string `json:"kind"`     // token, id, cookie
}

type DryRunner struct {
	Program *scenario.Program
	// BaseURL is the target the relative paths join.
	BaseURL string
	Env     map[string]string
	Secrets map[string]string
	// Allow vets every request URL; it returns a reason when the request
	// must not be sent.
	Allow func(*url.URL) string
	// DataDir resolves relative feeder files. With ConfineData, files must
	// stay inside DataDir (server mode).
	DataDir     string
	ConfineData bool
	Redactor    *Redactor
	// Transport overrides the HTTP transport (tests).
	Transport http.RoundTripper
	// BodyLimit bounds recorded bodies (default 2 KiB).
	BodyLimit int
	// MaxRequests bounds requests per pass (default 100).
	MaxRequests int
	// GRPCFiles are descriptors for grpc steps (from the generator's .proto
	// inputs). Steps whose method is not there load their own proto or
	// protoset files, or ask the server's reflection service.
	GRPCFiles *protoregistry.Files
	// contains filtered or unexported fields
}

type Endpoint struct {
	Method string `json:"method"`
	// Path uses {name} for parameters, as in OpenAPI.
	Path    string `json:"path"`
	Summary string `json:"summary,omitempty"`
	// Auth is set when the endpoint needs credentials.
	Auth bool `json:"auth,omitempty"`
	// Source is openapi, har or log.
	Source string `json:"source"`
	// Count is how often the endpoint appeared in recorded traffic.
	Count int `json:"count,omitempty"`
}

type EndpointCoverage struct {
	Endpoint
	Journeys []string `json:"journeys,omitempty"`
}

type GRPCMethod struct {
	// Name is "package.Service/Method", as grpc steps write it.
	Name            string `json:"name"`
	Input           string `json:"input"`
	Output          string `json:"output"`
	ServerStreaming bool   `json:"serverStreaming,omitempty"`
	// Example is the request message as JSON with every field set to an
	// example value of its type.
	Example string `json:"example"`
	Comment string `json:"comment,omitempty"`
}

type Inputs struct {
	// Description is plain language: who the users are and what they do.
	Description string
	// OpenAPI is an OpenAPI 3.x document (YAML or JSON).
	OpenAPI []byte
	// HAR is a browser or proxy recording (HTTP Archive 1.2).
	HAR []byte
	// GraphQL is a GraphQL schema: an introspection result (JSON) or SDL.
	GraphQL []byte
	// GraphQLPath is where the GraphQL API is served (default /graphql).
	GraphQLPath string
	// AccessLog is a web server access log (common, combined or any format
	// with a quoted "METHOD /path" request line).
	AccessLog []byte
	// Existing is a scenario to compare the proposal with.
	Existing []byte
	// Proto holds .proto sources by file name (the name imports use). The
	// generator writes grpc steps for their services' methods.
	Proto map[string][]byte
	// ProtoPaths, when set, are the paths grpc steps name in proto: so a
	// run loads the same descriptors (the CLI passes the files it read).
	// Without them steps rely on the server's reflection service.
	ProtoPaths []string
	// ProtoImportPaths are directories where imports of the .proto files
	// that are not in Proto are found (CLI only; steps name them in
	// importPaths).
	ProtoImportPaths []string
}

type JourneyCheck struct {
	Journey string  `json:"journey"`
	OK      bool    `json:"ok"`
	Traces  []Trace `json:"traces"`
}

type JourneyResult struct {
	Name   string `json:"name"`
	Status string `json:"status"`
	// Attempts counts the dry runs of this journey across repair rounds.
	Attempts int      `json:"attempts"`
	Traces   []Trace  `json:"traces"`
	Problems []string `json:"problems,omitempty"`
}

type MixEntry struct {
	Endpoint string  `json:"endpoint"`
	Count    int     `json:"count"`
	Share    float64 `json:"share"`
}

type NarrateOptions struct {
	Provider  provider.Provider
	MaxTokens int // per reply; default 4000
	// Repairs is how many times a reply with uncited or unsupported claims
	// is sent back; default 1, negative disables.
	Repairs int
}

type Options struct {
	Provider provider.Provider
	// Target is the base URL of the system under test. It is required for
	// the dry run.
	Target string
	// AllowHosts are extra hosts requests may reach besides the target and
	// private addresses.
	AllowHosts []string
	// Env and Secrets back ${env.X} and ${secret.X} in the dry run. Secret
	// values are redacted everywhere.
	Env     map[string]string
	Secrets map[string]string
	// DryRun runs each journey once against Target.
	DryRun bool
	// MaxRepairs bounds repair rounds (0 uses DefaultMaxRepairs; negative
	// disables repair).
	MaxRepairs int
	// OmitBaseURL leaves target.baseURL out of the YAML (the server
	// supplies it from the run's target). Otherwise it is set to Target.
	OmitBaseURL bool
	// DataDir and ConfineData resolve file feeders in the dry run.
	DataDir     string
	ConfineData bool
	// TokenBudget stops calling the model once this many tokens were used
	// (0 means no limit).
	TokenBudget int64
	// MaxTokens bounds each reply (default 16000).
	MaxTokens int
	// Transport overrides the dry run's HTTP transport (tests).
	Transport http.RoundTripper
	// Progress receives stage changes. It must not block.
	Progress func(Progress)
}

type Problem struct {
	// Journey is the journey the problem belongs to; empty means the whole
	// scenario.
	Journey string `json:"journey,omitempty"`
	Message string `json:"message"`
	// Fatal problems make the scenario unusable: it does not validate or
	// it would send traffic to a blocked third party. Other problems flag
	// a journey for review.
	Fatal bool `json:"fatal,omitempty"`
}

type Progress struct {
	Stage   string
	Round   int
	Message string
	Usage   provider.Usage
}

type Redactor struct {
	// contains filtered or unexported fields
}

type RequestRef struct {
	Journey string `json:"journey"`
	Method  string `json:"method"`
	URL     string `json:"url"`
}

type Result struct {
	// YAML is the proposed scenario, with flagged journeys marked by a
	// comment. Empty when the model never produced a usable scenario.
	YAML     string             `json:"yaml"`
	Scenario *scenario.Scenario `json:"-"`
	Journeys []JourneyResult    `json:"journeys"`
	// Problems are static problems in the proposal (fatal ones mean the
	// YAML must not be used).
	Problems []Problem `json:"problems"`
	// Diff compares Inputs.Existing with the proposal.
	Diff          string         `json:"diff,omitempty"`
	Usage         provider.Usage `json:"usage"`
	Rounds        int            `json:"rounds"`
	Provider      string         `json:"provider"`
	Model         string         `json:"model"`
	DryRun        bool           `json:"dryRun"`
	Understanding *Understanding `json:"understanding,omitempty"`
}

type SpecDiff struct {
	Added   []Endpoint            `json:"added,omitempty"`
	Removed []Endpoint            `json:"removed,omitempty"`
	Broken  map[string][]Endpoint `json:"broken,omitempty"` // journey -> removed endpoints it calls
}

type StepTrace struct {
	Step            string            `json:"step"`
	Method          string            `json:"method,omitempty"`
	URL             string            `json:"url,omitempty"`
	RequestHeaders  map[string]string `json:"requestHeaders,omitempty"`
	RequestBody     string            `json:"requestBody,omitempty"`
	Status          int               `json:"status,omitempty"`
	ResponseHeaders map[string]string `json:"responseHeaders,omitempty"`
	ResponseBody    string            `json:"responseBody,omitempty"`
	DurationMs      float64           `json:"durationMs"`
	Extracted       map[string]string `json:"extracted,omitempty"`
	Checks          []CheckResult     `json:"checks,omitempty"`
	OK              bool              `json:"ok"`
	Error           string            `json:"error,omitempty"`
	// Note explains a step that was not executed as a request.
	Note string `json:"note,omitempty"`
}

type ThirdPartyCall struct {
	// Journey and Step locate the call; both are empty for the target's
	// base URL.
	Journey  string `json:"journey,omitempty"`
	Step     string `json:"step,omitempty"`
	Host     string `json:"host"`
	Category string `json:"category"`
}

type Trace struct {
	// Pass numbers passes from 1. A journey with branches gets one pass
	// per alternative so every branch is exercised.
	Pass     int         `json:"pass"`
	Branches []string    `json:"branches,omitempty"`
	OK       bool        `json:"ok"`
	Error    string      `json:"error,omitempty"`
	Steps    []StepTrace `json:"steps"`
}

type Understanding struct {
	Endpoints    []Endpoint     `json:"endpoints"`
	Dependencies []Dependency   `json:"dependencies"`
	Mix          []MixEntry     `json:"mix,omitempty"`
	Visits       []VisitPattern `json:"visits,omitempty"`
	// HasSpec is set when endpoints come from OpenAPI or a HAR, so the
	// static check can require every request to use a known endpoint.
	HasSpec bool `json:"hasSpec"`
	// BasePath is the path of the spec's first server URL ("/api/v1"),
	// which prefixes every spec path on the wire.
	BasePath string `json:"basePath,omitempty"`
	// GRPCMethods are the methods of the .proto inputs; ProtoFiles their
	// compiled descriptors, which the dry run uses.
	GRPCMethods []GRPCMethod         `json:"grpcMethods,omitempty"`
	ProtoFiles  *protoregistry.Files `json:"-"`
	// Context is the redacted text the model sees.
	Context string `json:"-"`
}

type VisitPattern struct {
	Steps []string `json:"steps"`
	Count int      `json:"count"`
	Share float64  `json:"share"`
}