execution

type Attempt[Response any] func(context.Context, routing.Attempt) (*Response, *failure.Failure, AttemptAction)

type AttemptAction uint8

type AttemptEvidence struct {
	Number     int
	Route      routing.Route
	Retry      int
	State      State
	StartedAt  time.Time
	FinishedAt time.Time
	Duration   time.Duration
	Failure    *failure.Failure
	// Credential names which credential plane paid for this attempt. It is
	// evidence about the attempt in the same sense the route is, and a
	// fallback can move between planes, so it is recorded per attempt rather
	// than once per request. A skipped attempt carries none.
	Credential  CredentialEvidence
	Transitions []Transition
}

type AttemptOutcome struct {
	Route      routing.Route
	Credential CredentialEvidence
	Failure    *failure.Failure
}

type Availability interface {
	Acquire(routing.Route) bool
	Release(routing.Route)
	RecordSuccess(routing.Route, time.Duration)
	RecordFailure(routing.Route, *failure.Failure, time.Duration)
}

type ChatAttempt func(context.Context, routing.Attempt) (*inference.ChatResponse, *failure.Failure, AttemptAction)

type ChatResult struct {
	Response   inference.ChatResponse
	Route      routing.Route
	Attempts   []AttemptEvidence
	StartedAt  time.Time
	FinishedAt time.Time
}

type Clock interface {
	Now() time.Time
	Sleep(context.Context, time.Duration) error
}

type Config struct {
	MaxAttempts        int
	MaxRetriesPerRoute int
	MaxElapsed         time.Duration
	RetryBackoff       time.Duration
	BackoffMultiplier  float64
	MaxBackoff         time.Duration
}

type CredentialEvidence struct {
	Owner CredentialOwner
	// Source is the caller's name for the plane the credential came from.
	// Execution never interprets it: the owner is what decides whether an
	// attempt may move the shared availability state, and the source is
	// carried only so an operator can later see which of the owner's planes
	// answered. Splitting the two keeps the credential vocabulary with the
	// package that owns it instead of mirroring it here.
	Source          string
	MaterialVersion string
	Accepted        bool
}

type CredentialOwner string

type EmbeddingAttempt func(context.Context, routing.Attempt) (*inference.EmbeddingResponse, *failure.Failure, AttemptAction)

type EmbeddingResult struct {
	Response   inference.EmbeddingResponse
	Route      routing.Route
	Attempts   []AttemptEvidence
	StartedAt  time.Time
	FinishedAt time.Time
}

type Error struct {
	Reason   error
	Failure  *failure.Failure
	Attempts []AttemptEvidence
}

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

type ManagedStream interface {
	Stream
	Attempts() []AttemptEvidence
	Committed() bool
	ModelUsed() string
}

type OutcomePublisher interface {
	PublishOutcome(AttemptOutcome)
}

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

type Result[Response any] struct {
	Response   Response
	Route      routing.Route
	Attempts   []AttemptEvidence
	StartedAt  time.Time
	FinishedAt time.Time
}

type State string

type Stream interface {
	Read() (*inference.StreamEvent, error)
	Close() error
}

type StreamAttempt func(context.Context, routing.Attempt) (Stream, *failure.Failure, AttemptAction)

type Transition struct {
	From State
	To   State
	At   time.Time
}