rpc

type Caller ¶

type Caller interface {
	Call(context.Context, Request) (json.RawMessage, error)
}

type CallerFunc ¶

type CallerFunc func(context.Context, Request) (json.RawMessage, error)

func (f CallerFunc) Call(ctx context.Context, request Request) (json.RawMessage, error)

type ConsumerError ¶

type ConsumerError struct{ Cause error }

func (e *ConsumerError) Error() string

func (e *ConsumerError) Unwrap() error

type ContextNotifier ¶

type ContextNotifier struct{}

func (ContextNotifier) Notify(ctx context.Context, notification *jsonrpc.Notification) error

type DecideTool ¶

type DecideTool func(context.Context, tasks.Owner, *jsonrpc.Request) (Decision, error)

DecideTool is pure planning/policy. It must never start execution. Schedule through the canonical runtime only after its owned task creation is durable.

type Decision ¶

type Decision struct {
	Create   *tasks.CreateOptions
	Required bool
}

type HTTPCaller ¶

type HTTPCaller struct {
	HeaderProvider func(context.Context) (http.Header, error)
	// contains filtered or unexported fields
}

HTTPCaller is a bounded JSON/SSE request adapter, with no retries or redirects. Configure host authentication through Client.Transport or HeaderProvider.

func NewHTTPCaller(endpoint string, client *http.Client) (*HTTPCaller, error)

func (c *HTTPCaller) Call(ctx context.Context, request Request) (json.RawMessage, error)

func (c *HTTPCaller) Listen(ctx context.Context, request Request, notify func(json.RawMessage) error) (json.RawMessage, error)

type HTTPHandler ¶

type HTTPHandler struct {
	Build func(context.Context, transport.Notifier) transport.Handler
	// Present Origin headers are denied by default. Hosts may explicitly admit
	// approved web origins; this does not replace request authentication.
	AllowOrigin func(string) bool
}

HTTPHandler is a bounded stateless July JSON-RPC/SSE adapter. Host middleware must install authenticated request context before Owner is consulted. Build receives a request-scoped notifier, just like viant/mcp's transport handler factory. Normal methods may delegate to the host's existing handler.

func (h HTTPHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)

type Handler ¶

type Handler struct {
	Next          transport.Handler
	Service       tasks.Backend
	Owner         OwnerResolver
	Decide        DecideTool
	Notifier      transport.Notifier
	Subscriptions *SubscriptionOptions
	// contains filtered or unexported fields
}

func (h *Handler) OnNotification(ctx context.Context, notification *jsonrpc.Notification)

func (h *Handler) Serve(ctx context.Context, request *jsonrpc.Request, response *jsonrpc.Response)

type OwnerResolver ¶

type OwnerResolver func(context.Context, *jsonrpc.Request) (tasks.Owner, error)

type Request ¶

type Request struct {
	Method  string
	Params  json.RawMessage
	Headers http.Header
}

type SerialNotifier ¶

type SerialNotifier struct {
	NotifyFunc func(context.Context, *jsonrpc.Notification) error
	// contains filtered or unexported fields
}

SerialNotifier prevents interleaved writes when one host transport is shared.

func (s *SerialNotifier) Notify(ctx context.Context, n *jsonrpc.Notification) error

type StreamCaller ¶

type StreamCaller interface {
	Listen(context.Context, Request, func(json.RawMessage) error) (json.RawMessage, error)
}

StreamCaller keeps subscriptions/listen open and reports only notifications. A nil error means a correlated graceful complete response was received.

type SubscriptionOptions ¶

type SubscriptionOptions struct {
	ReconcileInterval time.Duration
	MaxDuration       time.Duration
	MaxConcurrent     int
}

SubscriptionOptions enables the actual notification transport. Nil on Handler means unsupported. ReconcileInterval bounds loss/overflow recovery; MaxDuration bounds resource lifetime and ends with a graceful correlated result.

type TransportCaller ¶

type TransportCaller struct {
	Transport transport.Transport
	// contains filtered or unexported fields
}

TransportCaller uses a supplied MCP transport. For HTTP, its header provider must consume HeadersFromContext; stdio needs no routing headers. It adds no retry policy and does not change the transport's authentication context.

func (c *TransportCaller) Call(ctx context.Context, request Request) (json.RawMessage, error)