a2asrv

type AgentCardProducer interface {
	// Card returns a self-describing manifest for an agent. It provides essential
	// metadata including the agent's identity, capabilities, skills, supported
	// communication methods, and security requirements.
	Card(ctx context.Context) (*a2a.AgentCard, error)
}

type AgentCardProducerFn func(ctx context.Context) (*a2a.AgentCard, error)

type AgentExecutor interface {
	// Execute invokes the agent passing information about the request which triggered execution,
	// translates agent outputs to A2A events and writes them to the event queue.
	// Every invocation runs in a dedicated goroutine.
	//
	// Failures should generally be reported by writing events carrying the cancelation information
	// and task state. An error should be returned in special cases like a failure to write an event.
	Execute(ctx context.Context, reqCtx *RequestContext, queue eventqueue.Queue) error

	// Cancel is called when a client requests the agent to stop working on a task.
	// The simplest implementation can write a cancelation event to the queue and let
	// it be processed by the A2A server. If the events gets applied during an active execution the execution
	// Context gets canceled.
	//
	// An an error should be returned if the cancelation request cannot be processed or a queue write failed.
	Cancel(ctx context.Context, reqCtx *RequestContext, queue eventqueue.Queue) error
}

type AuthenticatedUser struct {
	UserName string
}

type CallContext struct {

	// User can be set by authentication middleware to provide information about
	// the user who initiated the request.
	User User
	// contains filtered or unexported fields
}

type CallInterceptor interface {
	// Before allows to observe, modify or reject a Request.
	// A new context.Context can be returned to pass information to one of the extension points.
	Before(ctx context.Context, callCtx *CallContext, req *Request) (context.Context, error)

	// After allows to observe, modify or reject a Response.
	After(ctx context.Context, callCtx *CallContext, resp *Response) error
}

type ClusterConfig struct {
	QueueManager eventqueue.Manager
	WorkQueue    workqueue.Queue
	TaskStore    TaskStore
}

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

type InterceptedHandler struct {
	// Handler is responsible for the actual processing of every call.
	Handler RequestHandler
	// Interceptors is a list of call interceptors which will be applied before and after each call.
	Interceptors []CallInterceptor
	// Logger is the logger which will be accessible from request scope context using log package
	// methods. Defaults to slog.Default() if not set.
	Logger *slog.Logger
}

type PassthroughCallInterceptor struct{}

type PushConfigStore interface {
	// Save creates or updates a push notification configuration for a task. If no ID is set
	// on the provided config, it will have a store-generated ID for the returned config.
	// PushConfig has an ID and a Task can have multiple associated configurations.
	Save(ctx context.Context, taskID a2a.TaskID, config *a2a.PushConfig) (*a2a.PushConfig, error)

	// Get retrieves a push configuration registered for a Task with the given configID.
	Get(ctx context.Context, taskID a2a.TaskID, configID string) (*a2a.PushConfig, error)

	// List retrieves all registered push configurations for a Task. Returning an error stops the execution.
	List(ctx context.Context, taskID a2a.TaskID) ([]*a2a.PushConfig, error)

	// Delete removes a push configuration registered for a Task with the given configID.
	Delete(ctx context.Context, taskID a2a.TaskID, configID string) error

	// DeleteAll removes all registered push configurations of a Task.
	DeleteAll(ctx context.Context, taskID a2a.TaskID) error
}

type PushSender interface {
	// SendPush sends a push notification containing the latest task state. If an error is returned execution is stopped.
	SendPush(ctx context.Context, config *a2a.PushConfig, task *a2a.Task) error
}

type ReferencedTasksLoader struct {
	Store TaskStore
}

type Request struct {
	// Payload is one of a2a package core types. It is nil when a request does not have any parameters.
	Payload any
}

type RequestContext struct {
	// A message which triggered the execution. nil for cancelation request.
	Message *a2a.Message
	// TaskID is an ID of the task or a newly generated UUIDv4 in case Message did not reference any Task.
	TaskID a2a.TaskID
	// StoredTask is present if request message specified a TaskID.
	StoredTask *a2a.Task
	// RelatedTasks can be present when Message includes Task references and RequestContextBuilder is configured to load them.
	RelatedTasks []*a2a.Task
	// ContextID is a server-generated identifier for maintaining context across multiple related tasks or interactions. Matches the Task ContextID.
	ContextID string
	// Metadata of the request which triggered the call.
	Metadata map[string]any
}

type RequestContextInterceptor interface {
	// Intercept has a chance to modify a RequestContext before it gets passed to AgentExecutor.
	Intercept(ctx context.Context, reqCtx *RequestContext) (context.Context, error)
}

type RequestHandler interface {
	// OnGetTask handles the 'tasks/get' protocol method.
	OnGetTask(ctx context.Context, query *a2a.TaskQueryParams) (*a2a.Task, error)

	// OnCancelTask handles the 'tasks/cancel' protocol method.
	OnCancelTask(ctx context.Context, id *a2a.TaskIDParams) (*a2a.Task, error)

	// OnSendMessage handles the 'message/send' protocol method (non-streaming).
	OnSendMessage(ctx context.Context, message *a2a.MessageSendParams) (a2a.SendMessageResult, error)

	// OnResubscribeToTask handles the `tasks/resubscribe` protocol method.
	OnResubscribeToTask(ctx context.Context, id *a2a.TaskIDParams) iter.Seq2[a2a.Event, error]

	// OnSendMessageStream handles the 'message/stream' protocol method (streaming).
	OnSendMessageStream(ctx context.Context, message *a2a.MessageSendParams) iter.Seq2[a2a.Event, error]

	// OnGetTaskPushConfig handles the `tasks/pushNotificationConfig/get` protocol method.
	OnGetTaskPushConfig(ctx context.Context, params *a2a.GetTaskPushConfigParams) (*a2a.TaskPushConfig, error)

	// OnListTaskPushConfig handles the `tasks/pushNotificationConfig/list` protocol method.
	OnListTaskPushConfig(ctx context.Context, params *a2a.ListTaskPushConfigParams) ([]*a2a.TaskPushConfig, error)

	// OnSetTaskPushConfig handles the `tasks/pushNotificationConfig/set` protocol method.
	OnSetTaskPushConfig(ctx context.Context, params *a2a.TaskPushConfig) (*a2a.TaskPushConfig, error)

	// OnDeleteTaskPushConfig handles the `tasks/pushNotificationConfig/delete` protocol method.
	OnDeleteTaskPushConfig(ctx context.Context, params *a2a.DeleteTaskPushConfigParams) error

	// GetAgentCard returns an extended a2a.AgentCard if configured.
	OnGetExtendedAgentCard(ctx context.Context) (*a2a.AgentCard, error)
}

type RequestHandlerOption func(*InterceptedHandler, *defaultRequestHandler)

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

type Response struct {
	// Payload is one of a2a package core types. It is nil when Err is set or when a request does not return any value.
	Payload any
	// Err is set to indicate that request processing failed.
	Err error
}

type TaskStore interface {
	// Save stores a task. Implementations might choose to store event and use the previous known TaskVersion
	// for optimistic concurrency control during updates.
	Save(ctx context.Context, task *a2a.Task, event a2a.Event, prev a2a.TaskVersion) (a2a.TaskVersion, error)

	// Get retrieves a task by ID. If a Task doesn't exist the method should return [a2a.ErrTaskNotFound].
	Get(ctx context.Context, taskID a2a.TaskID) (*a2a.Task, a2a.TaskVersion, error)

	// List retrieves a list of tasks based on the provided request.
	List(ctx context.Context, req *a2a.ListTasksRequest) (*a2a.ListTasksResponse, error)
}

type User interface {
	// Name returns a username.
	Name() string
	// Authenticated returns true if the request was authenticated.
	Authenticated() bool
}