a2a

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

type AgentCard struct {
	Name                 string           `json:"name"`
	Description          string           `json:"description,omitempty"`
	URL                  string           `json:"url"`
	Version              string           `json:"version,omitempty"`
	ProtocolVersion      string           `json:"protocolVersion,omitempty"`
	PreferredTransport   string           `json:"preferredTransport,omitempty"`
	AdditionalInterfaces []AgentInterface `json:"additionalInterfaces,omitempty"`
	Capabilities         Capabilities     `json:"capabilities,omitempty"`
	DefaultInputModes    []string         `json:"defaultInputModes,omitempty"`
	DefaultOutputModes   []string         `json:"defaultOutputModes,omitempty"`
	Skills               []AgentSkill     `json:"skills,omitempty"`

	// SecuritySchemes / Security advertise the auth the endpoint
	// requires (mast as A2A server, docs/a2a-design.md "Auth model").
	// The client tolerates both absent (unauthenticated remote); the
	// server emits them when any exposed skill requires auth.
	SecuritySchemes *SecuritySchemes      `json:"securitySchemes,omitempty"`
	Security        []map[string][]string `json:"security,omitempty"`
}

type AgentConfig struct {
	// Name is the reference name: a2a://<name>/<skill>. Must be
	// lowercase because the name travels in the URI host position of a
	// federation reference, where RFC 3986 case-insensitivity means
	// parsers normalize to lowercase (see federation.ParseReference).
	Name string `yaml:"name"`

	// AgentCardURL locates the agent card. A base URL (empty or "/"
	// path) gets WellKnownCardPath appended. The JSON-RPC endpoint is
	// then resolved from the card.
	AgentCardURL string `yaml:"agent_card_url,omitempty"`

	// Endpoint is the JSON-RPC endpoint, bypassing card discovery.
	// When both Endpoint and AgentCardURL are set, Endpoint wins for
	// transport and the card is still fetched for skill validation.
	Endpoint string `yaml:"endpoint,omitempty"`

	// Skills is the subset of the agent's skills mast may invoke;
	// empty = all (docs/a2a-design.md).
	Skills []string `yaml:"skills,omitempty"`

	// Auth is optional; absent means unauthenticated calls.
	Auth *AuthConfig `yaml:"auth,omitempty"`

	// TimeoutSeconds bounds each invocation; 0 = DefaultTimeout.
	TimeoutSeconds int `yaml:"timeout_seconds,omitempty"`

	// Filename records provenance for error messages.
	Filename string `yaml:"-"`
}

type AgentInterface struct {
	Transport string `json:"transport"`
	URL       string `json:"url"`
}

type AgentSkill struct {
	ID          string   `json:"id"`
	Name        string   `json:"name,omitempty"`
	Description string   `json:"description,omitempty"`
	Tags        []string `json:"tags,omitempty"`
	InputModes  []string `json:"inputModes,omitempty"`
	OutputModes []string `json:"outputModes,omitempty"`
}

type Artifact struct {
	ArtifactID  string `json:"artifactId,omitempty"`
	Name        string `json:"name,omitempty"`
	Description string `json:"description,omitempty"`
	Parts       []Part `json:"parts,omitempty"`
}

type AuthConfig struct {
	// Type is the auth mechanism; v0.1: "bearer" only.
	Type string `yaml:"type"`

	// TokenEnv names the environment variable holding the bearer
	// token. Resolved at request time, not load time, so rotation
	// does not require a config reload.
	TokenEnv string `yaml:"token_env"`
}

type Backend interface {
	// GetTask returns the task snapshot, or ErrTaskNotFound.
	GetTask(ctx context.Context, taskID string) (TaskInfo, error)

	// CancelTask requests cancellation (idempotent), returning the
	// resulting snapshot, or ErrTaskNotFound.
	CancelTask(ctx context.Context, taskID, reason string) (TaskInfo, error)

	// SubmitMessage runs a message/send turn through the mast turn
	// chokepoint and returns the resolved task id and its terminal
	// snapshot. Continuing a task whose id is unknown returns
	// ErrTaskNotFound; a turn that runs but errors is reported through the
	// snapshot's State (failed / canceled / input-required), not an error
	// return. The ctx carries any propagated caller trace context.
	SubmitMessage(ctx context.Context, p SubmitParams) (taskID string, info TaskInfo, err error)

	// StreamMessage runs a message/stream turn through the same chokepoint
	// as SubmitMessage, emitting streaming updates through emit as the turn
	// progresses. emit is called synchronously and in order on the calling
	// goroutine — the SSE handler writes each frame to the wire — so
	// implementations need no locking around it. The first emit is the
	// initial *Task snapshot; subsequent emits are *TaskStatusUpdateEvent
	// progress updates (final=false). The returned task id and terminal
	// snapshot let the server emit the closing artifact + a final
	// status-update. Error semantics mirror SubmitMessage (ErrTaskNotFound
	// / ErrUnavailable before any emit; a turn that runs but fails is
	// reported through the snapshot State). A backend must not emit after
	// returning.
	StreamMessage(ctx context.Context, p SubmitParams, emit func(any)) (taskID string, info TaskInfo, err error)
}

type Capabilities struct {
	Streaming         bool `json:"streaming,omitempty"`
	PushNotifications bool `json:"pushNotifications,omitempty"`
}

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

type ClientOption func(*Client)

type Config struct {
	// Listen is the bind address, e.g. ":7780". Used by ListenAndServe.
	Listen string

	// Skills are the exposed workloads. An empty slice serves a card
	// with no skills; the daemon only starts the server when at least
	// one workload opts in.
	Skills []ExposedSkill

	// Validator authenticates every /a2a request. Nil disables auth
	// (dev only) — like inject's empty BearerToken. When set, a request
	// without a valid bearer is refused 401 before any dispatch.
	Validator TokenValidator

	// Backend is required.
	Backend Backend

	// Limiter, when non-nil, admits or refuses each turn-driving request
	// (message/send) before dispatch — see RateLimiter. Nil disables rate
	// limiting. Control-plane verbs (tasks/get, tasks/cancel) are never
	// gated.
	Limiter RateLimiter

	// CardName / CardDescription / CardVersion populate the aggregated
	// agent card. CardName defaults to "mast".
	CardName        string
	CardDescription string
	CardVersion     string

	// ExternalURL overrides the card's request-derived url.
	ExternalURL string

	// Metric, when non-nil, records task outcomes.
	Metric TaskMetric

	// Logger defaults to slog.Default().
	Logger *slog.Logger

	// BaseContext, when non-nil, is the context every request derives
	// from (the daemon passes its turn lifetime, as for inject).
	BaseContext context.Context
}

type ExposedSkill struct {
	// WorkloadName is the mast workload backing this skill; the task
	// registry maps a submitted skill call to it (Stage B), and task
	// verbs resolve required scopes through it.
	WorkloadName string

	// SkillName is the A2A skill id/name (bundle a2a.skill_name).
	SkillName string

	// Description is rendered into the card skill. The daemon may fold
	// the mast-side input/output schema hints into it — spec AgentSkill
	// has no schema fields (docs/a2a-design.md note).
	Description string

	// Tags surface on the card skill; defaults to ["mast"] when empty.
	Tags []string

	// Scopes are required to invoke this skill. Empty means the skill
	// needs authentication only (a valid token, no specific scope) when
	// a validator is configured, or open access when it is not.
	Scopes []string
}

type Message struct {
	Kind      string         `json:"kind"`
	MessageID string         `json:"messageId"`
	Role      string         `json:"role"`
	Parts     []Part         `json:"parts"`
	TaskID    string         `json:"taskId,omitempty"`
	ContextID string         `json:"contextId,omitempty"`
	Metadata  map[string]any `json:"metadata,omitempty"`
}

type Part struct {
	Kind     string         `json:"kind"`
	Text     string         `json:"text,omitempty"`
	Data     map[string]any `json:"data,omitempty"`
	Metadata map[string]any `json:"metadata,omitempty"`
}

type Principal = serverauth.Principal

type RPCError struct {
	Code    int             `json:"code"`
	Message string          `json:"message"`
	Data    json.RawMessage `json:"data,omitempty"`
}

type RateLimitRequest = serverauth.RateLimitRequest

type RateLimiter = serverauth.RateLimiter

type SecurityScheme struct {
	Type   string `json:"type"`   // const "http"
	Scheme string `json:"scheme"` // const "Bearer"
}

type SecuritySchemes struct {
	Bearer *SecurityScheme `json:"bearer,omitempty"`
}

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

type StaticBearerValidator = serverauth.StaticBearerValidator

type SubmitParams struct {
	// TaskID continues an existing task (== session id) when set; empty
	// mints a fresh task.
	TaskID string

	// ContextID groups related messages; carried onto the task snapshot.
	ContextID string

	// Text is the joined text of the inbound message's parts.
	Text string
}

type Task struct {
	Kind      string     `json:"kind"`
	ID        string     `json:"id"`
	ContextID string     `json:"contextId,omitempty"`
	Status    TaskStatus `json:"status"`
	Artifacts []Artifact `json:"artifacts,omitempty"`
}

type TaskArtifactUpdateEvent struct {
	Kind      string         `json:"kind"` // "artifact-update"
	TaskID    string         `json:"taskId"`
	ContextID string         `json:"contextId,omitempty"`
	Artifact  Artifact       `json:"artifact"`
	Append    bool           `json:"append,omitempty"`
	LastChunk bool           `json:"lastChunk,omitempty"`
	Metadata  map[string]any `json:"metadata,omitempty"`
}

type TaskInfo struct {
	// WorkloadName owns the task; it resolves the skill for scope checks.
	WorkloadName string

	// State is the A2A lifecycle state, mapped from the session's
	// log-proven state by the backend. A transcript-only read never
	// reports "completed" (the event log cannot prove a turn finished
	// versus is in flight) — that state comes from the in-process task
	// registry in Stage B.
	State TaskState

	// ContextID groups related messages; optional in Stage A.
	ContextID string

	// StatusMessage is an optional human-readable status line surfaced in
	// the task's status.message.
	StatusMessage string

	// Output is the agent's answer for a completed task; when non-empty
	// it surfaces as a text artifact on the returned Task (Stage B
	// message/send). Empty for read/cancel snapshots.
	Output string
}

type TaskMetric interface {
	A2ATask(workload, outcome string)
}

type TaskState string

type TaskStatus struct {
	State   TaskState `json:"state"`
	Message *Message  `json:"message,omitempty"`
}

type TaskStatusUpdateEvent struct {
	Kind      string         `json:"kind"` // "status-update"
	TaskID    string         `json:"taskId"`
	ContextID string         `json:"contextId,omitempty"`
	Status    TaskStatus     `json:"status"`
	Final     bool           `json:"final"`
	Metadata  map[string]any `json:"metadata,omitempty"`
}

type TokenBucketLimiter = serverauth.TokenBucketLimiter

type TokenValidator = serverauth.TokenValidator