taskexec

type Canceler interface {
	// Cancel attempts to cancel a Task.
	// Expected to produce a Task update event with canceled state.
	Cancel(context.Context, eventqueue.Queue) error
}

type Cleaner interface {
	// Cleanup is called after execution or cancellation with the final result.
	Cleanup(context.Context, a2a.SendMessageResult, error)
}

type DistributedManagerConfig struct {
	WorkQueue         workqueue.Queue
	QueueManager      eventqueue.Manager
	Factory           Factory
	TaskStore         TaskStore
	ConcurrencyConfig limiter.ConcurrencyConfig
	Logger            *slog.Logger
	PanicHandler      PanicHandlerFn
}

type Executor interface {
	// Start starts publishing events to the queue. Called in a separate goroutine.
	Execute(context.Context, eventqueue.Queue) error
}

type Factory interface {
	// CreateExecutor is used to create initialized Executor and Processor for a Task execution which will run in separate goroutines.
	CreateExecutor(context.Context, a2a.TaskID, *a2a.MessageSendParams) (Executor, Processor, Cleaner, error)

	// CreateCanceler is used to create initialized Canceler and Processor for a Task cancelation which will run in separate goroutines.
	CreateCanceler(context.Context, *a2a.TaskIDParams) (Canceler, Processor, Cleaner, error)
}

type LocalManagerConfig struct {
	QueueManager      eventqueue.Manager
	ConcurrencyConfig limiter.ConcurrencyConfig
	Factory           Factory
	PanicHandler      PanicHandlerFn
}

type Manager interface {
	// Resubscribe is used to resubscribe to events of an active execution.
	Resubscribe(ctx context.Context, taskID a2a.TaskID) (Subscription, error)
	// Execute requests an execution for handling a received message.
	Execute(ctx context.Context, params *a2a.MessageSendParams) (Subscription, error)
	// Cancel requests a task cancelation.
	Cancel(ctx context.Context, params *a2a.TaskIDParams) (*a2a.Task, error)
}

type PanicHandlerFn func(r any) error

type Processor interface {
	// Process is called for each event produced by the started Execution. Called in a separate goroutine.
	Process(context.Context, a2a.Event) (*ProcessorResult, error)

	// ProcessError is called when an execution error is encountered to try recovering from it.
	// If it returns a result, the returned value becomes the result of the execution. If an error can't be handled
	// either a modified error or the original error cause must be returned.
	ProcessError(context.Context, error) (a2a.SendMessageResult, error)
}

type ProcessorResult struct {
	// ExecutionResult becomes the result of the execution if a non-nil value is returned.
	ExecutionResult a2a.SendMessageResult
	// ExecutionFailureCause can be returned by the processor to pass information about why the execution stopped to event producer.
	// It is set when ExecutionResult is not a direct consequence of executor-emitted event: for example, a malformed event was received and task was moved to failed state.
	// The cause will be accessible using context.Cause(ctx) in the executor code.
	ExecutionFailureCause error
	// TaskVersion is the version of the task after the event was processed.
	TaskVersion a2a.TaskVersion
	// EventOverride can be returned by the processor to change which event gets emitted to subscribers.
	// This is useful when we failed to process a malformed event and moved the task to failed state.
	EventOverride a2a.Event
}

type Subscription interface {
	// TaskID is ID of the task to which this subscription is related.
	TaskID() a2a.TaskID
	// Events returns a sequence of events. If error is returned the sequence is terminated.
	// This method can only be called once.
	Events(ctx context.Context) iter.Seq2[a2a.Event, error]
}

type TaskStore interface {
	Get(context.Context, a2a.TaskID) (*a2a.Task, a2a.TaskVersion, error)
}