1146 lines
43 KiB
Go
1146 lines
43 KiB
Go
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
|
|
// version: proto synapse v1.0.0
|
|
|
|
package grpcapi
|
|
|
|
import (
|
|
context "context"
|
|
grpc "google.golang.org/grpc"
|
|
codes "google.golang.org/grpc/codes"
|
|
status "google.golang.org/grpc/status"
|
|
emptypb "google.golang.org/protobuf/types/known/emptypb"
|
|
)
|
|
|
|
// TaskServiceClient is the client API for TaskService
|
|
type TaskServiceClient interface {
|
|
// SubmitTask submits a new task
|
|
SubmitTask(ctx context.Context, in *SubmitTaskRequest, opts ...grpc.CallOption) (*SubmitTaskResponse, error)
|
|
// SubmitTaskWithFiles submits a task with file attachments
|
|
SubmitTaskWithFiles(ctx context.Context, in *SubmitTaskWithFilesRequest, opts ...grpc.CallOption) (*SubmitTaskResponse, error)
|
|
// GetTask gets task details
|
|
GetTask(ctx context.Context, in *GetTaskRequest, opts ...grpc.CallOption) (*TaskStatusResponse, error)
|
|
// GetTaskStatus gets simplified task status
|
|
GetTaskStatus(ctx context.Context, in *GetTaskRequest, opts ...grpc.CallOption) (*TaskStatusResponse, error)
|
|
// ListTasks lists tasks with filtering
|
|
ListTasks(ctx context.Context, in *ListTasksRequest, opts ...grpc.CallOption) (*ListTasksResponse, error)
|
|
// CancelTask cancels a task
|
|
CancelTask(ctx context.Context, in *CancelTaskRequest, opts ...grpc.CallOption) (*CancelTaskResponse, error)
|
|
// StreamTaskStatus streams task status updates (bidirectional streaming)
|
|
StreamTaskStatus(ctx context.Context, opts ...grpc.CallOption) (TaskService_StreamTaskStatusClient, error)
|
|
}
|
|
|
|
type taskServiceClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewTaskServiceClient(cc grpc.ClientConnInterface) TaskServiceClient {
|
|
return &taskServiceClient{cc}
|
|
}
|
|
|
|
func (c *taskServiceClient) SubmitTask(ctx context.Context, in *SubmitTaskRequest, opts ...grpc.CallOption) (*SubmitTaskResponse, error) {
|
|
out := new(SubmitTaskResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.TaskService/SubmitTask", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) SubmitTaskWithFiles(ctx context.Context, in *SubmitTaskWithFilesRequest, opts ...grpc.CallOption) (*SubmitTaskResponse, error) {
|
|
out := new(SubmitTaskResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.TaskService/SubmitTaskWithFiles", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) GetTask(ctx context.Context, in *GetTaskRequest, opts ...grpc.CallOption) (*TaskStatusResponse, error) {
|
|
out := new(TaskStatusResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.TaskService/GetTask", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) GetTaskStatus(ctx context.Context, in *GetTaskRequest, opts ...grpc.CallOption) (*TaskStatusResponse, error) {
|
|
out := new(TaskStatusResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.TaskService/GetTaskStatus", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) ListTasks(ctx context.Context, in *ListTasksRequest, opts ...grpc.CallOption) (*ListTasksResponse, error) {
|
|
out := new(ListTasksResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.TaskService/ListTasks", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) CancelTask(ctx context.Context, in *CancelTaskRequest, opts ...grpc.CallOption) (*CancelTaskResponse, error) {
|
|
out := new(CancelTaskResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.TaskService/CancelTask", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *taskServiceClient) StreamTaskStatus(ctx context.Context, opts ...grpc.CallOption) (TaskService_StreamTaskStatusClient, error) {
|
|
stream, err := c.cc.NewStream(ctx, &TaskService_ServiceDesc.Streams[0], "/a2a.TaskService/StreamTaskStatus", opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
x := &taskServiceStreamTaskStatusClient{stream}
|
|
return x, nil
|
|
}
|
|
|
|
type TaskService_StreamTaskStatusClient interface {
|
|
Send(*TaskStatusStreamRequest) error
|
|
Recv() (*TaskStatusUpdate, error)
|
|
grpc.ClientStream
|
|
}
|
|
|
|
type taskServiceStreamTaskStatusClient struct {
|
|
grpc.ClientStream
|
|
}
|
|
|
|
func (x *taskServiceStreamTaskStatusClient) Send(m *TaskStatusStreamRequest) error {
|
|
return x.ClientStream.SendMsg(m)
|
|
}
|
|
|
|
func (x *taskServiceStreamTaskStatusClient) Recv() (*TaskStatusUpdate, error) {
|
|
m := new(TaskStatusUpdate)
|
|
if err := x.ClientStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
// TaskServiceServer is the server API for TaskService
|
|
type TaskServiceServer interface {
|
|
SubmitTask(context.Context, *SubmitTaskRequest) (*SubmitTaskResponse, error)
|
|
SubmitTaskWithFiles(context.Context, *SubmitTaskWithFilesRequest) (*SubmitTaskResponse, error)
|
|
GetTask(context.Context, *GetTaskRequest) (*TaskStatusResponse, error)
|
|
GetTaskStatus(context.Context, *GetTaskRequest) (*TaskStatusResponse, error)
|
|
ListTasks(context.Context, *ListTasksRequest) (*ListTasksResponse, error)
|
|
CancelTask(context.Context, *CancelTaskRequest) (*CancelTaskResponse, error)
|
|
StreamTaskStatus(TaskService_StreamTaskStatusServer) error
|
|
}
|
|
|
|
// UnimplementedTaskServiceServer can be embedded to have forward compatible implementations.
|
|
type UnimplementedTaskServiceServer struct {
|
|
}
|
|
|
|
func (UnimplementedTaskServiceServer) SubmitTask(context.Context, *SubmitTaskRequest) (*SubmitTaskResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method SubmitTask not implemented")
|
|
}
|
|
|
|
func (UnimplementedTaskServiceServer) SubmitTaskWithFiles(context.Context, *SubmitTaskWithFilesRequest) (*SubmitTaskResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method SubmitTaskWithFiles not implemented")
|
|
}
|
|
|
|
func (UnimplementedTaskServiceServer) GetTask(context.Context, *GetTaskRequest) (*TaskStatusResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method GetTask not implemented")
|
|
}
|
|
|
|
func (UnimplementedTaskServiceServer) GetTaskStatus(context.Context, *GetTaskRequest) (*TaskStatusResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method GetTaskStatus not implemented")
|
|
}
|
|
|
|
func (UnimplementedTaskServiceServer) ListTasks(context.Context, *ListTasksRequest) (*ListTasksResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method ListTasks not implemented")
|
|
}
|
|
|
|
func (UnimplementedTaskServiceServer) CancelTask(context.Context, *CancelTaskRequest) (*CancelTaskResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method CancelTask not implemented")
|
|
}
|
|
|
|
func (UnimplementedTaskServiceServer) StreamTaskStatus(TaskService_StreamTaskStatusServer) error {
|
|
return status.Errorf(codes.Unimplemented, "method StreamTaskStatus not implemented")
|
|
}
|
|
|
|
type TaskService_StreamTaskStatusServer interface {
|
|
Send(*TaskStatusUpdate) error
|
|
Recv() (*TaskStatusStreamRequest, error)
|
|
grpc.ServerStream
|
|
}
|
|
|
|
type taskServiceStreamStatusServer struct {
|
|
grpc.ServerStream
|
|
}
|
|
|
|
func (x *taskServiceStreamStatusServer) Send(m *TaskStatusUpdate) error {
|
|
return x.ServerStream.SendMsg(m)
|
|
}
|
|
|
|
func (x *taskServiceStreamStatusServer) Recv() (*TaskStatusStreamRequest, error) {
|
|
m := new(TaskStatusStreamRequest)
|
|
if err := x.ServerStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
// TaskService_ServiceDesc is the grpc.ServiceDesc for TaskService
|
|
var TaskService_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "a2a.TaskService",
|
|
HandlerType: (*TaskServiceServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "SubmitTask",
|
|
Handler: _TaskService_SubmitTask_Handler,
|
|
},
|
|
{
|
|
MethodName: "SubmitTaskWithFiles",
|
|
Handler: _TaskService_SubmitTaskWithFiles_Handler,
|
|
},
|
|
{
|
|
MethodName: "GetTask",
|
|
Handler: _TaskService_GetTask_Handler,
|
|
},
|
|
{
|
|
MethodName: "GetTaskStatus",
|
|
Handler: _TaskService_GetTaskStatus_Handler,
|
|
},
|
|
{
|
|
MethodName: "ListTasks",
|
|
Handler: _TaskService_ListTasks_Handler,
|
|
},
|
|
{
|
|
MethodName: "CancelTask",
|
|
Handler: _TaskService_CancelTask_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{
|
|
{
|
|
StreamName: "StreamTaskStatus",
|
|
Handler: _TaskService_StreamTaskStatus_Handler,
|
|
ServerStreams: true,
|
|
ClientStreams: true,
|
|
},
|
|
},
|
|
Metadata: "a2a.proto",
|
|
}
|
|
|
|
func _TaskService_SubmitTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SubmitTaskRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).SubmitTask(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/a2a.TaskService/SubmitTask",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).SubmitTask(ctx, req.(*SubmitTaskRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_SubmitTaskWithFiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SubmitTaskWithFilesRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).SubmitTaskWithFiles(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/a2a.TaskService/SubmitTaskWithFiles",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).SubmitTaskWithFiles(ctx, req.(*SubmitTaskWithFilesRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_GetTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(GetTaskRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).GetTask(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/a2a.TaskService/GetTask",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).GetTask(ctx, req.(*GetTaskRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_GetTaskStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(GetTaskRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).GetTaskStatus(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/a2a.TaskService/GetTaskStatus",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).GetTaskStatus(ctx, req.(*GetTaskRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_ListTasks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ListTasksRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).ListTasks(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/a2a.TaskService/ListTasks",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).ListTasks(ctx, req.(*ListTasksRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_CancelTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CancelTaskRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(TaskServiceServer).CancelTask(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/a2a.TaskService/CancelTask",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(TaskServiceServer).CancelTask(ctx, req.(*CancelTaskRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _TaskService_StreamTaskStatus_Handler(srv interface{}, stream grpc.ServerStream) error {
|
|
return srv.(TaskServiceServer).StreamTaskStatus(&taskServiceStreamStatusServer{ServerStream: stream})
|
|
}
|
|
|
|
// =============================================================================
|
|
// A2AMessageService
|
|
// =============================================================================
|
|
|
|
// A2AMessageServiceClient is the client API for A2AMessageService
|
|
type A2AMessageServiceClient interface {
|
|
// SendMessage sends a single Synapse message
|
|
SendMessage(ctx context.Context, in *SendMessageRequest, opts ...grpc.CallOption) (*SendMessageResponse, error)
|
|
// StreamMessages streams Synapse messages (bidirectional streaming)
|
|
StreamMessages(ctx context.Context, opts ...grpc.CallOption) (A2AMessageService_StreamMessagesClient, error)
|
|
// ReceiveCallback receives callback messages (server streaming)
|
|
ReceiveCallback(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (A2AMessageService_ReceiveCallbackClient, error)
|
|
}
|
|
|
|
type a2aMessageServiceClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewA2AMessageServiceClient(cc grpc.ClientConnInterface) A2AMessageServiceClient {
|
|
return &a2aMessageServiceClient{cc}
|
|
}
|
|
|
|
func (c *a2aMessageServiceClient) SendMessage(ctx context.Context, in *SendMessageRequest, opts ...grpc.CallOption) (*SendMessageResponse, error) {
|
|
out := new(SendMessageResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.A2AMessageService/SendMessage", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *a2aMessageServiceClient) StreamMessages(ctx context.Context, opts ...grpc.CallOption) (A2AMessageService_StreamMessagesClient, error) {
|
|
stream, err := c.cc.NewStream(ctx, &A2AMessageService_ServiceDesc.Streams[0], "/a2a.A2AMessageService/StreamMessages", opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
x := &a2aMessageServiceStreamMessagesClient{stream}
|
|
return x, nil
|
|
}
|
|
|
|
type A2AMessageService_StreamMessagesClient interface {
|
|
Send(*A2AMessage) error
|
|
Recv() (*A2AMessage, error)
|
|
grpc.ClientStream
|
|
}
|
|
|
|
type a2aMessageServiceStreamMessagesClient struct {
|
|
grpc.ClientStream
|
|
}
|
|
|
|
func (x *a2aMessageServiceStreamMessagesClient) Send(m *A2AMessage) error {
|
|
return x.ClientStream.SendMsg(m)
|
|
}
|
|
|
|
func (x *a2aMessageServiceStreamMessagesClient) Recv() (*A2AMessage, error) {
|
|
m := new(A2AMessage)
|
|
if err := x.ClientStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func (c *a2aMessageServiceClient) ReceiveCallback(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (A2AMessageService_ReceiveCallbackClient, error) {
|
|
stream, err := c.cc.NewStream(ctx, &A2AMessageService_ServiceDesc.Streams[1], "/a2a.A2AMessageService/ReceiveCallback", opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
x := &a2aMessageServiceReceiveCallbackClient{stream}
|
|
return x, nil
|
|
}
|
|
|
|
type A2AMessageService_ReceiveCallbackClient interface {
|
|
Recv() (*A2AMessage, error)
|
|
grpc.ClientStream
|
|
}
|
|
|
|
type a2aMessageServiceReceiveCallbackClient struct {
|
|
grpc.ClientStream
|
|
}
|
|
|
|
func (x *a2aMessageServiceReceiveCallbackClient) Recv() (*A2AMessage, error) {
|
|
m := new(A2AMessage)
|
|
if err := x.ClientStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
// A2AMessageServiceServer is the server API for A2AMessageService
|
|
type A2AMessageServiceServer interface {
|
|
SendMessage(context.Context, *SendMessageRequest) (*SendMessageResponse, error)
|
|
StreamMessages(A2AMessageService_StreamMessagesServer) error
|
|
ReceiveCallback(*emptypb.Empty, A2AMessageService_ReceiveCallbackServer) error
|
|
}
|
|
|
|
// UnimplementedA2AMessageServiceServer can be embedded to have forward compatible implementations.
|
|
type UnimplementedA2AMessageServiceServer struct {
|
|
}
|
|
|
|
func (UnimplementedA2AMessageServiceServer) SendMessage(context.Context, *SendMessageRequest) (*SendMessageResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method SendMessage not implemented")
|
|
}
|
|
|
|
func (UnimplementedA2AMessageServiceServer) StreamMessages(A2AMessageService_StreamMessagesServer) error {
|
|
return status.Errorf(codes.Unimplemented, "method StreamMessages not implemented")
|
|
}
|
|
|
|
func (UnimplementedA2AMessageServiceServer) ReceiveCallback(*emptypb.Empty, A2AMessageService_ReceiveCallbackServer) error {
|
|
return status.Errorf(codes.Unimplemented, "method ReceiveCallback not implemented")
|
|
}
|
|
|
|
type A2AMessageService_StreamMessagesServer interface {
|
|
Send(*A2AMessage) error
|
|
Recv() (*A2AMessage, error)
|
|
grpc.ServerStream
|
|
}
|
|
|
|
type a2aMessageServiceStreamMessagesServer struct {
|
|
grpc.ServerStream
|
|
}
|
|
|
|
func (x *a2aMessageServiceStreamMessagesServer) Send(m *A2AMessage) error {
|
|
return x.ServerStream.SendMsg(m)
|
|
}
|
|
|
|
func (x *a2aMessageServiceStreamMessagesServer) Recv() (*A2AMessage, error) {
|
|
m := new(A2AMessage)
|
|
if err := x.ServerStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
type A2AMessageService_ReceiveCallbackServer interface {
|
|
Send(*A2AMessage) error
|
|
grpc.ServerStream
|
|
}
|
|
|
|
type a2aMessageServiceReceiveCallbackServer struct {
|
|
grpc.ServerStream
|
|
}
|
|
|
|
func (x *a2aMessageServiceReceiveCallbackServer) Send(m *A2AMessage) error {
|
|
return x.ServerStream.SendMsg(m)
|
|
}
|
|
|
|
// A2AMessageService_ServiceDesc is the grpc.ServiceDesc for A2AMessageService
|
|
var A2AMessageService_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "a2a.A2AMessageService",
|
|
HandlerType: (*A2AMessageServiceServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "SendMessage",
|
|
Handler: _A2AMessageService_SendMessage_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{
|
|
{
|
|
StreamName: "StreamMessages",
|
|
Handler: _A2AMessageService_StreamMessages_Handler,
|
|
ServerStreams: true,
|
|
ClientStreams: true,
|
|
},
|
|
{
|
|
StreamName: "ReceiveCallback",
|
|
Handler: _A2AMessageService_ReceiveCallback_Handler,
|
|
ServerStreams: true,
|
|
},
|
|
},
|
|
Metadata: "a2a.proto",
|
|
}
|
|
|
|
func _A2AMessageService_SendMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SendMessageRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(A2AMessageServiceServer).SendMessage(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/a2a.A2AMessageService/SendMessage",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(A2AMessageServiceServer).SendMessage(ctx, req.(*SendMessageRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _A2AMessageService_StreamMessages_Handler(srv interface{}, stream grpc.ServerStream) error {
|
|
return srv.(A2AMessageServiceServer).StreamMessages(&a2aMessageServiceStreamMessagesServer{ServerStream: stream})
|
|
}
|
|
|
|
func _A2AMessageService_ReceiveCallback_Handler(srv interface{}, stream grpc.ServerStream) error {
|
|
m := new(emptypb.Empty)
|
|
if err := stream.RecvMsg(m); err != nil {
|
|
return err
|
|
}
|
|
return srv.(A2AMessageServiceServer).ReceiveCallback(m, &a2aMessageServiceReceiveCallbackServer{ServerStream: stream})
|
|
}
|
|
|
|
// =============================================================================
|
|
// CapabilitiesService
|
|
// =============================================================================
|
|
|
|
// CapabilitiesServiceClient is the client API for CapabilitiesService
|
|
type CapabilitiesServiceClient interface {
|
|
GetCapabilities(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CapabilitiesResponse, error)
|
|
QueryAgent(ctx context.Context, in *QueryAgentRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error)
|
|
ListAgents(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListAgentsResponse, error)
|
|
}
|
|
|
|
type capabilitiesServiceClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewCapabilitiesServiceClient(cc grpc.ClientConnInterface) CapabilitiesServiceClient {
|
|
return &capabilitiesServiceClient{cc}
|
|
}
|
|
|
|
func (c *capabilitiesServiceClient) GetCapabilities(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*CapabilitiesResponse, error) {
|
|
out := new(CapabilitiesResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.CapabilitiesService/GetCapabilities", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *capabilitiesServiceClient) QueryAgent(ctx context.Context, in *QueryAgentRequest, opts ...grpc.CallOption) (*CapabilitiesResponse, error) {
|
|
out := new(CapabilitiesResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.CapabilitiesService/QueryAgent", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *capabilitiesServiceClient) ListAgents(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListAgentsResponse, error) {
|
|
out := new(ListAgentsResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.CapabilitiesService/ListAgents", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// CapabilitiesServiceServer is the server API for CapabilitiesService
|
|
type CapabilitiesServiceServer interface {
|
|
GetCapabilities(context.Context, *emptypb.Empty) (*CapabilitiesResponse, error)
|
|
QueryAgent(context.Context, *QueryAgentRequest) (*CapabilitiesResponse, error)
|
|
ListAgents(context.Context, *emptypb.Empty) (*ListAgentsResponse, error)
|
|
}
|
|
|
|
// UnimplementedCapabilitiesServiceServer can be embedded to have forward compatible implementations.
|
|
type UnimplementedCapabilitiesServiceServer struct {
|
|
}
|
|
|
|
func (UnimplementedCapabilitiesServiceServer) GetCapabilities(context.Context, *emptypb.Empty) (*CapabilitiesResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method GetCapabilities not implemented")
|
|
}
|
|
|
|
func (UnimplementedCapabilitiesServiceServer) QueryAgent(context.Context, *QueryAgentRequest) (*CapabilitiesResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method QueryAgent not implemented")
|
|
}
|
|
|
|
func (UnimplementedCapabilitiesServiceServer) ListAgents(context.Context, *emptypb.Empty) (*ListAgentsResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method ListAgents not implemented")
|
|
}
|
|
|
|
// CapabilitiesService_ServiceDesc is the grpc.ServiceDesc for CapabilitiesService
|
|
var CapabilitiesService_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "a2a.CapabilitiesService",
|
|
HandlerType: (*CapabilitiesServiceServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "GetCapabilities",
|
|
Handler: _CapabilitiesService_GetCapabilities_Handler,
|
|
},
|
|
{
|
|
MethodName: "QueryAgent",
|
|
Handler: _CapabilitiesService_QueryAgent_Handler,
|
|
},
|
|
{
|
|
MethodName: "ListAgents",
|
|
Handler: _CapabilitiesService_ListAgents_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
Metadata: "a2a.proto",
|
|
}
|
|
|
|
func _CapabilitiesService_GetCapabilities_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(emptypb.Empty)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(CapabilitiesServiceServer).GetCapabilities(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/a2a.CapabilitiesService/GetCapabilities",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(CapabilitiesServiceServer).GetCapabilities(ctx, req.(*emptypb.Empty))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _CapabilitiesService_QueryAgent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(QueryAgentRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(CapabilitiesServiceServer).QueryAgent(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/a2a.CapabilitiesService/QueryAgent",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(CapabilitiesServiceServer).QueryAgent(ctx, req.(*QueryAgentRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _CapabilitiesService_ListAgents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(emptypb.Empty)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(CapabilitiesServiceServer).ListAgents(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: "/a2a.CapabilitiesService/ListAgents",
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(CapabilitiesServiceServer).ListAgents(ctx, req.(*emptypb.Empty))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
// =============================================================================
|
|
// GroupService
|
|
// =============================================================================
|
|
|
|
// GroupServiceClient is the client API for GroupService
|
|
type GroupServiceClient interface {
|
|
CreateGroup(ctx context.Context, in *CreateGroupRequest, opts ...grpc.CallOption) (*CreateGroupResponse, error)
|
|
JoinGroup(ctx context.Context, in *JoinGroupRequest, opts ...grpc.CallOption) (*JoinGroupResponse, error)
|
|
LeaveGroup(ctx context.Context, in *LeaveGroupRequest, opts ...grpc.CallOption) (*LeaveGroupResponse, error)
|
|
DisbandGroup(ctx context.Context, in *DisbandGroupRequest, opts ...grpc.CallOption) (*DisbandGroupResponse, error)
|
|
ListGroupMembers(ctx context.Context, in *ListGroupMembersRequest, opts ...grpc.CallOption) (*ListGroupMembersResponse, error)
|
|
StreamGroupMessages(ctx context.Context, opts ...grpc.CallOption) (GroupService_StreamGroupMessagesClient, error)
|
|
// Voting
|
|
InitiateVote(ctx context.Context, in *VoteRequest, opts ...grpc.CallOption) (*VoteResponse, error)
|
|
SubmitVote(ctx context.Context, in *SubmitVoteRequest, opts ...grpc.CallOption) (*SubmitVoteResponse, error)
|
|
GetVoteStatus(ctx context.Context, in *GetVoteStatusRequest, opts ...grpc.CallOption) (*VoteStatusResponse, error)
|
|
// Task Split
|
|
SplitTask(ctx context.Context, in *SplitTaskRequest, opts ...grpc.CallOption) (*SplitTaskResponse, error)
|
|
MergeResults(ctx context.Context, in *MergeResultsRequest, opts ...grpc.CallOption) (*MergeResultsResponse, error)
|
|
}
|
|
|
|
type groupServiceClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewGroupServiceClient(cc grpc.ClientConnInterface) GroupServiceClient {
|
|
return &groupServiceClient{cc}
|
|
}
|
|
|
|
func (c *groupServiceClient) CreateGroup(ctx context.Context, in *CreateGroupRequest, opts ...grpc.CallOption) (*CreateGroupResponse, error) {
|
|
out := new(CreateGroupResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.GroupService/CreateGroup", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *groupServiceClient) JoinGroup(ctx context.Context, in *JoinGroupRequest, opts ...grpc.CallOption) (*JoinGroupResponse, error) {
|
|
out := new(JoinGroupResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.GroupService/JoinGroup", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *groupServiceClient) LeaveGroup(ctx context.Context, in *LeaveGroupRequest, opts ...grpc.CallOption) (*LeaveGroupResponse, error) {
|
|
out := new(LeaveGroupResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.GroupService/LeaveGroup", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *groupServiceClient) DisbandGroup(ctx context.Context, in *DisbandGroupRequest, opts ...grpc.CallOption) (*DisbandGroupResponse, error) {
|
|
out := new(DisbandGroupResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.GroupService/DisbandGroup", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *groupServiceClient) ListGroupMembers(ctx context.Context, in *ListGroupMembersRequest, opts ...grpc.CallOption) (*ListGroupMembersResponse, error) {
|
|
out := new(ListGroupMembersResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.GroupService/ListGroupMembers", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *groupServiceClient) StreamGroupMessages(ctx context.Context, opts ...grpc.CallOption) (GroupService_StreamGroupMessagesClient, error) {
|
|
stream, err := c.cc.NewStream(ctx, &GroupService_ServiceDesc.Streams[0], "/a2a.GroupService/StreamGroupMessages", opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
x := &groupServiceStreamGroupMessagesClient{stream}
|
|
return x, nil
|
|
}
|
|
|
|
type GroupService_StreamGroupMessagesClient interface {
|
|
Send(*A2AMessage) error
|
|
Recv() (*A2AMessage, error)
|
|
grpc.ClientStream
|
|
}
|
|
|
|
type groupServiceStreamGroupMessagesClient struct {
|
|
grpc.ClientStream
|
|
}
|
|
|
|
func (x *groupServiceStreamGroupMessagesClient) Send(m *A2AMessage) error {
|
|
return x.ClientStream.SendMsg(m)
|
|
}
|
|
|
|
func (x *groupServiceStreamGroupMessagesClient) Recv() (*A2AMessage, error) {
|
|
m := new(A2AMessage)
|
|
if err := x.ClientStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func (c *groupServiceClient) InitiateVote(ctx context.Context, in *VoteRequest, opts ...grpc.CallOption) (*VoteResponse, error) {
|
|
out := new(VoteResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.GroupService/InitiateVote", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *groupServiceClient) SubmitVote(ctx context.Context, in *SubmitVoteRequest, opts ...grpc.CallOption) (*SubmitVoteResponse, error) {
|
|
out := new(SubmitVoteResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.GroupService/SubmitVote", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *groupServiceClient) GetVoteStatus(ctx context.Context, in *GetVoteStatusRequest, opts ...grpc.CallOption) (*VoteStatusResponse, error) {
|
|
out := new(VoteStatusResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.GroupService/GetVoteStatus", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *groupServiceClient) SplitTask(ctx context.Context, in *SplitTaskRequest, opts ...grpc.CallOption) (*SplitTaskResponse, error) {
|
|
out := new(SplitTaskResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.GroupService/SplitTask", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *groupServiceClient) MergeResults(ctx context.Context, in *MergeResultsRequest, opts ...grpc.CallOption) (*MergeResultsResponse, error) {
|
|
out := new(MergeResultsResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.GroupService/MergeResults", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// GroupServiceServer is the server API for GroupService
|
|
type GroupServiceServer interface {
|
|
CreateGroup(context.Context, *CreateGroupRequest) (*CreateGroupResponse, error)
|
|
JoinGroup(context.Context, *JoinGroupRequest) (*JoinGroupResponse, error)
|
|
LeaveGroup(context.Context, *LeaveGroupRequest) (*LeaveGroupResponse, error)
|
|
DisbandGroup(context.Context, *DisbandGroupRequest) (*DisbandGroupResponse, error)
|
|
ListGroupMembers(context.Context, *ListGroupMembersRequest) (*ListGroupMembersResponse, error)
|
|
StreamGroupMessages(GroupService_StreamGroupMessagesServer) error
|
|
// Voting
|
|
InitiateVote(context.Context, *VoteRequest) (*VoteResponse, error)
|
|
SubmitVote(context.Context, *SubmitVoteRequest) (*SubmitVoteResponse, error)
|
|
GetVoteStatus(context.Context, *GetVoteStatusRequest) (*VoteStatusResponse, error)
|
|
// Task Split
|
|
SplitTask(context.Context, *SplitTaskRequest) (*SplitTaskResponse, error)
|
|
MergeResults(context.Context, *MergeResultsRequest) (*MergeResultsResponse, error)
|
|
}
|
|
|
|
// UnimplementedGroupServiceServer can be embedded to have forward compatible implementations.
|
|
type UnimplementedGroupServiceServer struct {
|
|
}
|
|
|
|
func (UnimplementedGroupServiceServer) CreateGroup(context.Context, *CreateGroupRequest) (*CreateGroupResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method CreateGroup not implemented")
|
|
}
|
|
|
|
func (UnimplementedGroupServiceServer) JoinGroup(context.Context, *JoinGroupRequest) (*JoinGroupResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method JoinGroup not implemented")
|
|
}
|
|
|
|
func (UnimplementedGroupServiceServer) LeaveGroup(context.Context, *LeaveGroupRequest) (*LeaveGroupResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method LeaveGroup not implemented")
|
|
}
|
|
|
|
func (UnimplementedGroupServiceServer) DisbandGroup(context.Context, *DisbandGroupRequest) (*DisbandGroupResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method DisbandGroup not implemented")
|
|
}
|
|
|
|
func (UnimplementedGroupServiceServer) ListGroupMembers(context.Context, *ListGroupMembersRequest) (*ListGroupMembersResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method ListGroupMembers not implemented")
|
|
}
|
|
|
|
func (UnimplementedGroupServiceServer) StreamGroupMessages(GroupService_StreamGroupMessagesServer) error {
|
|
return status.Errorf(codes.Unimplemented, "method StreamGroupMessages not implemented")
|
|
}
|
|
|
|
func (UnimplementedGroupServiceServer) InitiateVote(context.Context, *VoteRequest) (*VoteResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method InitiateVote not implemented")
|
|
}
|
|
|
|
func (UnimplementedGroupServiceServer) SubmitVote(context.Context, *SubmitVoteRequest) (*SubmitVoteResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method SubmitVote not implemented")
|
|
}
|
|
|
|
func (UnimplementedGroupServiceServer) GetVoteStatus(context.Context, *GetVoteStatusRequest) (*VoteStatusResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method GetVoteStatus not implemented")
|
|
}
|
|
|
|
func (UnimplementedGroupServiceServer) SplitTask(context.Context, *SplitTaskRequest) (*SplitTaskResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method SplitTask not implemented")
|
|
}
|
|
|
|
func (UnimplementedGroupServiceServer) MergeResults(context.Context, *MergeResultsRequest) (*MergeResultsResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method MergeResults not implemented")
|
|
}
|
|
|
|
type GroupService_StreamGroupMessagesServer interface {
|
|
Send(*A2AMessage) error
|
|
Recv() (*A2AMessage, error)
|
|
grpc.ServerStream
|
|
}
|
|
|
|
type groupServiceStreamMessagesServer struct {
|
|
grpc.ServerStream
|
|
}
|
|
|
|
func (x *groupServiceStreamMessagesServer) Send(m *A2AMessage) error {
|
|
return x.ServerStream.SendMsg(m)
|
|
}
|
|
|
|
func (x *groupServiceStreamMessagesServer) Recv() (*A2AMessage, error) {
|
|
m := new(A2AMessage)
|
|
if err := x.ServerStream.RecvMsg(m); err != nil {
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
// GroupService_ServiceDesc is the grpc.ServiceDesc for GroupService
|
|
var GroupService_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "a2a.GroupService",
|
|
HandlerType: (*GroupServiceServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{MethodName: "CreateGroup", Handler: _GroupService_CreateGroup_Handler},
|
|
{MethodName: "JoinGroup", Handler: _GroupService_JoinGroup_Handler},
|
|
{MethodName: "LeaveGroup", Handler: _GroupService_LeaveGroup_Handler},
|
|
{MethodName: "DisbandGroup", Handler: _GroupService_DisbandGroup_Handler},
|
|
{MethodName: "ListGroupMembers", Handler: _GroupService_ListGroupMembers_Handler},
|
|
{MethodName: "InitiateVote", Handler: _GroupService_InitiateVote_Handler},
|
|
{MethodName: "SubmitVote", Handler: _GroupService_SubmitVote_Handler},
|
|
{MethodName: "GetVoteStatus", Handler: _GroupService_GetVoteStatus_Handler},
|
|
{MethodName: "SplitTask", Handler: _GroupService_SplitTask_Handler},
|
|
{MethodName: "MergeResults", Handler: _GroupService_MergeResults_Handler},
|
|
},
|
|
Streams: []grpc.StreamDesc{
|
|
{StreamName: "StreamGroupMessages", Handler: _GroupService_StreamGroupMessages_Handler, ServerStreams: true, ClientStreams: true},
|
|
},
|
|
Metadata: "a2a.proto",
|
|
}
|
|
|
|
func _GroupService_CreateGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CreateGroupRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(GroupServiceServer).CreateGroup(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/CreateGroup"}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GroupServiceServer).CreateGroup(ctx, req.(*CreateGroupRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GroupService_JoinGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(JoinGroupRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/JoinGroup"}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GroupServiceServer).JoinGroup(ctx, req.(*JoinGroupRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GroupService_LeaveGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(LeaveGroupRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/LeaveGroup"}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GroupServiceServer).LeaveGroup(ctx, req.(*LeaveGroupRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GroupService_DisbandGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(DisbandGroupRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/DisbandGroup"}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GroupServiceServer).DisbandGroup(ctx, req.(*DisbandGroupRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GroupService_ListGroupMembers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ListGroupMembersRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/ListGroupMembers"}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GroupServiceServer).ListGroupMembers(ctx, req.(*ListGroupMembersRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GroupService_StreamGroupMessages_Handler(srv interface{}, stream grpc.ServerStream) error {
|
|
return srv.(GroupServiceServer).StreamGroupMessages(&groupServiceStreamMessagesServer{ServerStream: stream})
|
|
}
|
|
|
|
func _GroupService_InitiateVote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(VoteRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/InitiateVote"}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GroupServiceServer).InitiateVote(ctx, req.(*VoteRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GroupService_SubmitVote_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SubmitVoteRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/SubmitVote"}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GroupServiceServer).SubmitVote(ctx, req.(*SubmitVoteRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GroupService_GetVoteStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(GetVoteStatusRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/GetVoteStatus"}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GroupServiceServer).GetVoteStatus(ctx, req.(*GetVoteStatusRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GroupService_SplitTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SplitTaskRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/SplitTask"}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GroupServiceServer).SplitTask(ctx, req.(*SplitTaskRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _GroupService_MergeResults_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(MergeResultsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.GroupService/MergeResults"}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(GroupServiceServer).MergeResults(ctx, req.(*MergeResultsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
// =============================================================================
|
|
// HealthService
|
|
// =============================================================================
|
|
|
|
// HealthServiceClient is the client API for HealthService
|
|
type HealthServiceClient interface {
|
|
HealthCheck(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthCheckResponse, error)
|
|
}
|
|
|
|
type healthServiceClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewHealthServiceClient(cc grpc.ClientConnInterface) HealthServiceClient {
|
|
return &healthServiceClient{cc}
|
|
}
|
|
|
|
func (c *healthServiceClient) HealthCheck(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*HealthCheckResponse, error) {
|
|
out := new(HealthCheckResponse)
|
|
err := c.cc.Invoke(ctx, "/a2a.HealthService/HealthCheck", in, out, opts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// HealthServiceServer is the server API for HealthService
|
|
type HealthServiceServer interface {
|
|
HealthCheck(context.Context, *emptypb.Empty) (*HealthCheckResponse, error)
|
|
}
|
|
|
|
// UnimplementedHealthServiceServer can be embedded to have forward compatible implementations.
|
|
type UnimplementedHealthServiceServer struct {
|
|
}
|
|
|
|
func (UnimplementedHealthServiceServer) HealthCheck(context.Context, *emptypb.Empty) (*HealthCheckResponse, error) {
|
|
return nil, status.Errorf(codes.Unimplemented, "method HealthCheck not implemented")
|
|
}
|
|
|
|
// HealthService_ServiceDesc is the grpc.ServiceDesc for HealthService
|
|
var HealthService_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "a2a.HealthService",
|
|
HandlerType: (*HealthServiceServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{MethodName: "HealthCheck", Handler: _HealthService_HealthCheck_Handler},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
Metadata: "a2a.proto",
|
|
}
|
|
|
|
func _HealthService_HealthCheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(emptypb.Empty)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(HealthServiceServer).HealthCheck(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{Server: srv, FullMethod: "/a2a.HealthService/HealthCheck"}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(HealthServiceServer).HealthCheck(ctx, req.(*emptypb.Empty))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
var _ HealthServiceServer = (HealthServiceServer)(nil)
|
|
|
|
func init() {
|
|
// Register all services
|
|
}
|