a2a

type Agent interface {
	// Run handles one inbound A2A message, containing only plain text, and
	// yields the reply as a sequence of text chunks. A single-shot agent
	// yields once; a streaming agent yields deltas. A yielded error ends the
	// task as failed and stops iteration. Errors are internal diagnostics; the
	// remote task receives a fixed failure message without their contents.
	Run(ctx context.Context, input string) iter.Seq2[string, error]
}

type Endpoint struct {
	// Name overrides the model-visible tool name. Empty derives it from the
	// resolved AgentCard.
	Name string

	// CardURL is the absolute HTTP(S) AgentCard URL.
	CardURL string

	// ContinuationIdentity is the Host's stable, non-secret identity for the
	// endpoint's principal and execution revision. Reuse it across reconstruction
	// only while both remain the same. Empty confines continuations to this
	// ToolSet's lifetime; HTTPClient credentials cannot establish durable identity.
	ContinuationIdentity string

	// HTTPClient serves card resolution and RPC calls. Nil uses
	// http.DefaultClient. The caller retains ownership; a restricted shallow
	// copy is used internally.
	HTTPClient *http.Client

	// CardTimeout bounds AgentCard resolution only. Zero selects 30 seconds; it
	// does not impose a timeout on long-running agent RPC calls.
	CardTimeout time.Duration

	// CardMaxBytes bounds the decoded AgentCard response body before parsing.
	// Zero selects 1 MiB. Excess data returns an *http.MaxBytesError, even if a
	// valid card precedes it. This limit does not apply to RPC responses.
	CardMaxBytes int64

	// AllowedRPCOrigins adds trusted RPC origins beyond CardURL's own origin.
	// Entries use the exact "scheme://host[:port]" form. Empty prevents an
	// AgentCard from redirecting calls to another origin.
	AllowedRPCOrigins []string

	// ConcurrencyPolicy belongs to the host because distinct remote task IDs do
	// not establish resource independence. Nil supplies no overlap declaration.
	ConcurrencyPolicy ToolConcurrencyPolicy

	// Effect is the host's replay guarantee for this endpoint. A message ID or
	// task ID alone does not prove durable deduplication; the default is unsafe.
	Effect toolcontract.Effect
}

type ProtocolServerConfig struct {
	// Card has the requirements of [ServerConfig.Card] apart from its text-only
	// modes; Handler owns the semantics of every capability it declares.
	Card *sdka2a.AgentCard

	Handler a2asrv.RequestHandler

	// MaxRequestBytes has the meaning of [ServerConfig.MaxRequestBytes].
	MaxRequestBytes int64
}

type RemoteAgentError struct {
	State sdka2a.TaskState

	Detail string
}

type ServerConfig struct {
	Agent Agent

	// Card is the AgentCard served at the well-known path. Required and
	// snapshotted during construction. SupportedInterfaces must contain exactly
	// one JSON-RPC interface using the SDK's protocol version and an absolute
	// HTTP(S) URL. Its path is the exact RPC route; hosts own public-origin
	// routing and reverse-proxy configuration. Its Capabilities must not declare
	// push notifications or an extended agent card, which this handler does not
	// provide. Default and skill input/output modes may declare only text/plain,
	// which the Agent boundary can represent. Streaming and input modes are
	// enforced from the published snapshot.
	Card *sdka2a.AgentCard

	// TaskStore persists A2A task state and is required: the Host owns the store
	// and its retention rather than inheriting a hidden default. The SDK's bundled
	// in-memory store (taskstore.NewInMemory) keeps every task for the process
	// lifetime with no eviction, so a long-running server must supply a store it
	// can bound; a short-lived one may pass that in-memory store explicitly.
	TaskStore taskstore.Store

	// MaxRequestBytes bounds one RPC request body. The protocol decoder buffers a
	// whole request before any authentication or admission can refuse it, so an
	// unbounded body lets any caller choose this server's memory use. Zero selects
	// 4 MiB, far above an ordinary text or JSON message; a Host exchanging larger
	// payloads raises it.
	MaxRequestBytes int64
}

type ToolConcurrencyPolicy func(toolcontract.Invocation) (key string, concurrent bool)

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

type WaitAddress struct {
	Process string `json:"process"`
	Key     string `json:"key"`
}