execution

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
	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
	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 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
}