1116 lines
47 KiB
Go
1116 lines
47 KiB
Go
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
|
|
// versions:
|
|
// - protoc-gen-go-grpc v1.6.2
|
|
// - protoc (unknown)
|
|
// source: gateway/v1/chat.proto
|
|
|
|
package gatewayv1
|
|
|
|
import (
|
|
context "context"
|
|
grpc "google.golang.org/grpc"
|
|
codes "google.golang.org/grpc/codes"
|
|
status "google.golang.org/grpc/status"
|
|
)
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
// is compatible with the grpc package it is being compiled against.
|
|
// Requires gRPC-Go v1.64.0 or later.
|
|
const _ = grpc.SupportPackageIsVersion9
|
|
|
|
const (
|
|
ChatService_RecentLogs_FullMethodName = "/gateway.v1.ChatService/RecentLogs"
|
|
ChatService_Snapshot_FullMethodName = "/gateway.v1.ChatService/Snapshot"
|
|
ChatService_GetSession_FullMethodName = "/gateway.v1.ChatService/GetSession"
|
|
ChatService_RecentMessages_FullMethodName = "/gateway.v1.ChatService/RecentMessages"
|
|
ChatService_RecentTurns_FullMethodName = "/gateway.v1.ChatService/RecentTurns"
|
|
ChatService_Route_FullMethodName = "/gateway.v1.ChatService/Route"
|
|
ChatService_Stream_FullMethodName = "/gateway.v1.ChatService/Stream"
|
|
ChatService_Answer_FullMethodName = "/gateway.v1.ChatService/Answer"
|
|
ChatService_Cancel_FullMethodName = "/gateway.v1.ChatService/Cancel"
|
|
ChatService_StopTasks_FullMethodName = "/gateway.v1.ChatService/StopTasks"
|
|
ChatService_ApplyTaskAction_FullMethodName = "/gateway.v1.ChatService/ApplyTaskAction"
|
|
ChatService_ApplyOperatorTaskAction_FullMethodName = "/gateway.v1.ChatService/ApplyOperatorTaskAction"
|
|
ChatService_SaveSession_FullMethodName = "/gateway.v1.ChatService/SaveSession"
|
|
ChatService_GetSessionsByChannel_FullMethodName = "/gateway.v1.ChatService/GetSessionsByChannel"
|
|
ChatService_DeleteSession_FullMethodName = "/gateway.v1.ChatService/DeleteSession"
|
|
ChatService_TouchSession_FullMethodName = "/gateway.v1.ChatService/TouchSession"
|
|
ChatService_ListSessions_FullMethodName = "/gateway.v1.ChatService/ListSessions"
|
|
ChatService_SaveMessage_FullMethodName = "/gateway.v1.ChatService/SaveMessage"
|
|
ChatService_DeleteRecentMessages_FullMethodName = "/gateway.v1.ChatService/DeleteRecentMessages"
|
|
ChatService_MessageCount_FullMethodName = "/gateway.v1.ChatService/MessageCount"
|
|
ChatService_SaveMessages_FullMethodName = "/gateway.v1.ChatService/SaveMessages"
|
|
ChatService_ReplaceMessages_FullMethodName = "/gateway.v1.ChatService/ReplaceMessages"
|
|
ChatService_SearchMessages_FullMethodName = "/gateway.v1.ChatService/SearchMessages"
|
|
ChatService_ListSkills_FullMethodName = "/gateway.v1.ChatService/ListSkills"
|
|
ChatService_CuratorHealth_FullMethodName = "/gateway.v1.ChatService/CuratorHealth"
|
|
ChatService_ReloadChannel_FullMethodName = "/gateway.v1.ChatService/ReloadChannel"
|
|
ChatService_CheckSecret_FullMethodName = "/gateway.v1.ChatService/CheckSecret"
|
|
)
|
|
|
|
// ChatServiceClient is the client API for ChatService service.
|
|
//
|
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
|
|
type ChatServiceClient interface {
|
|
RecentLogs(ctx context.Context, in *RecentLogsRequest, opts ...grpc.CallOption) (*RecentLogsResponse, error)
|
|
Snapshot(ctx context.Context, in *SnapshotRequest, opts ...grpc.CallOption) (*SnapshotResponse, error)
|
|
GetSession(ctx context.Context, in *GetSessionRequest, opts ...grpc.CallOption) (*GetSessionResponse, error)
|
|
RecentMessages(ctx context.Context, in *RecentMessagesRequest, opts ...grpc.CallOption) (*RecentMessagesResponse, error)
|
|
RecentTurns(ctx context.Context, in *RecentTurnsRequest, opts ...grpc.CallOption) (*RecentTurnsResponse, error)
|
|
Route(ctx context.Context, in *RouteRequest, opts ...grpc.CallOption) (*RouteResponse, error)
|
|
Stream(ctx context.Context, in *StreamRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StreamResponse], error)
|
|
Answer(ctx context.Context, in *AnswerRequest, opts ...grpc.CallOption) (*AnswerResponse, error)
|
|
Cancel(ctx context.Context, in *CancelRequest, opts ...grpc.CallOption) (*CancelResponse, error)
|
|
StopTasks(ctx context.Context, in *StopTasksRequest, opts ...grpc.CallOption) (*StopTasksResponse, error)
|
|
ApplyTaskAction(ctx context.Context, in *ApplyTaskActionRequest, opts ...grpc.CallOption) (*ApplyTaskActionResponse, error)
|
|
ApplyOperatorTaskAction(ctx context.Context, in *ApplyOperatorTaskActionRequest, opts ...grpc.CallOption) (*ApplyOperatorTaskActionResponse, error)
|
|
SaveSession(ctx context.Context, in *SaveSessionRequest, opts ...grpc.CallOption) (*SaveSessionResponse, error)
|
|
GetSessionsByChannel(ctx context.Context, in *GetSessionsByChannelRequest, opts ...grpc.CallOption) (*GetSessionsByChannelResponse, error)
|
|
DeleteSession(ctx context.Context, in *DeleteSessionRequest, opts ...grpc.CallOption) (*DeleteSessionResponse, error)
|
|
TouchSession(ctx context.Context, in *TouchSessionRequest, opts ...grpc.CallOption) (*TouchSessionResponse, error)
|
|
ListSessions(ctx context.Context, in *ListSessionsRequest, opts ...grpc.CallOption) (*ListSessionsResponse, error)
|
|
SaveMessage(ctx context.Context, in *SaveMessageRequest, opts ...grpc.CallOption) (*SaveMessageResponse, error)
|
|
DeleteRecentMessages(ctx context.Context, in *DeleteRecentMessagesRequest, opts ...grpc.CallOption) (*DeleteRecentMessagesResponse, error)
|
|
MessageCount(ctx context.Context, in *MessageCountRequest, opts ...grpc.CallOption) (*MessageCountResponse, error)
|
|
SaveMessages(ctx context.Context, in *SaveMessagesRequest, opts ...grpc.CallOption) (*SaveMessagesResponse, error)
|
|
ReplaceMessages(ctx context.Context, in *ReplaceMessagesRequest, opts ...grpc.CallOption) (*ReplaceMessagesResponse, error)
|
|
SearchMessages(ctx context.Context, in *SearchMessagesRequest, opts ...grpc.CallOption) (*SearchMessagesResponse, error)
|
|
ListSkills(ctx context.Context, in *ListSkillsRequest, opts ...grpc.CallOption) (*ListSkillsResponse, error)
|
|
CuratorHealth(ctx context.Context, in *CuratorHealthRequest, opts ...grpc.CallOption) (*CuratorHealthResponse, error)
|
|
ReloadChannel(ctx context.Context, in *ReloadChannelRequest, opts ...grpc.CallOption) (*ReloadChannelResponse, error)
|
|
// CheckSecret reports resolution in this process without returning a value.
|
|
CheckSecret(ctx context.Context, in *CheckSecretRequest, opts ...grpc.CallOption) (*CheckSecretResponse, error)
|
|
}
|
|
|
|
type chatServiceClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewChatServiceClient(cc grpc.ClientConnInterface) ChatServiceClient {
|
|
return &chatServiceClient{cc}
|
|
}
|
|
|
|
func (c *chatServiceClient) RecentLogs(ctx context.Context, in *RecentLogsRequest, opts ...grpc.CallOption) (*RecentLogsResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(RecentLogsResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_RecentLogs_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) Snapshot(ctx context.Context, in *SnapshotRequest, opts ...grpc.CallOption) (*SnapshotResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(SnapshotResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_Snapshot_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) GetSession(ctx context.Context, in *GetSessionRequest, opts ...grpc.CallOption) (*GetSessionResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(GetSessionResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_GetSession_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) RecentMessages(ctx context.Context, in *RecentMessagesRequest, opts ...grpc.CallOption) (*RecentMessagesResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(RecentMessagesResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_RecentMessages_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) RecentTurns(ctx context.Context, in *RecentTurnsRequest, opts ...grpc.CallOption) (*RecentTurnsResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(RecentTurnsResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_RecentTurns_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) Route(ctx context.Context, in *RouteRequest, opts ...grpc.CallOption) (*RouteResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(RouteResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_Route_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) Stream(ctx context.Context, in *StreamRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[StreamResponse], error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
stream, err := c.cc.NewStream(ctx, &ChatService_ServiceDesc.Streams[0], ChatService_Stream_FullMethodName, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
x := &grpc.GenericClientStream[StreamRequest, StreamResponse]{ClientStream: stream}
|
|
if err := x.ClientStream.SendMsg(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := x.ClientStream.CloseSend(); err != nil {
|
|
return nil, err
|
|
}
|
|
return x, nil
|
|
}
|
|
|
|
// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
|
|
type ChatService_StreamClient = grpc.ServerStreamingClient[StreamResponse]
|
|
|
|
func (c *chatServiceClient) Answer(ctx context.Context, in *AnswerRequest, opts ...grpc.CallOption) (*AnswerResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(AnswerResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_Answer_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) Cancel(ctx context.Context, in *CancelRequest, opts ...grpc.CallOption) (*CancelResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CancelResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_Cancel_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) StopTasks(ctx context.Context, in *StopTasksRequest, opts ...grpc.CallOption) (*StopTasksResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(StopTasksResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_StopTasks_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) ApplyTaskAction(ctx context.Context, in *ApplyTaskActionRequest, opts ...grpc.CallOption) (*ApplyTaskActionResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ApplyTaskActionResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_ApplyTaskAction_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) ApplyOperatorTaskAction(ctx context.Context, in *ApplyOperatorTaskActionRequest, opts ...grpc.CallOption) (*ApplyOperatorTaskActionResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ApplyOperatorTaskActionResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_ApplyOperatorTaskAction_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) SaveSession(ctx context.Context, in *SaveSessionRequest, opts ...grpc.CallOption) (*SaveSessionResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(SaveSessionResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_SaveSession_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) GetSessionsByChannel(ctx context.Context, in *GetSessionsByChannelRequest, opts ...grpc.CallOption) (*GetSessionsByChannelResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(GetSessionsByChannelResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_GetSessionsByChannel_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) DeleteSession(ctx context.Context, in *DeleteSessionRequest, opts ...grpc.CallOption) (*DeleteSessionResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(DeleteSessionResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_DeleteSession_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) TouchSession(ctx context.Context, in *TouchSessionRequest, opts ...grpc.CallOption) (*TouchSessionResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(TouchSessionResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_TouchSession_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) ListSessions(ctx context.Context, in *ListSessionsRequest, opts ...grpc.CallOption) (*ListSessionsResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ListSessionsResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_ListSessions_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) SaveMessage(ctx context.Context, in *SaveMessageRequest, opts ...grpc.CallOption) (*SaveMessageResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(SaveMessageResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_SaveMessage_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) DeleteRecentMessages(ctx context.Context, in *DeleteRecentMessagesRequest, opts ...grpc.CallOption) (*DeleteRecentMessagesResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(DeleteRecentMessagesResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_DeleteRecentMessages_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) MessageCount(ctx context.Context, in *MessageCountRequest, opts ...grpc.CallOption) (*MessageCountResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(MessageCountResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_MessageCount_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) SaveMessages(ctx context.Context, in *SaveMessagesRequest, opts ...grpc.CallOption) (*SaveMessagesResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(SaveMessagesResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_SaveMessages_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) ReplaceMessages(ctx context.Context, in *ReplaceMessagesRequest, opts ...grpc.CallOption) (*ReplaceMessagesResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ReplaceMessagesResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_ReplaceMessages_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) SearchMessages(ctx context.Context, in *SearchMessagesRequest, opts ...grpc.CallOption) (*SearchMessagesResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(SearchMessagesResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_SearchMessages_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) ListSkills(ctx context.Context, in *ListSkillsRequest, opts ...grpc.CallOption) (*ListSkillsResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ListSkillsResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_ListSkills_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) CuratorHealth(ctx context.Context, in *CuratorHealthRequest, opts ...grpc.CallOption) (*CuratorHealthResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CuratorHealthResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_CuratorHealth_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) ReloadChannel(ctx context.Context, in *ReloadChannelRequest, opts ...grpc.CallOption) (*ReloadChannelResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(ReloadChannelResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_ReloadChannel_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *chatServiceClient) CheckSecret(ctx context.Context, in *CheckSecretRequest, opts ...grpc.CallOption) (*CheckSecretResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CheckSecretResponse)
|
|
err := c.cc.Invoke(ctx, ChatService_CheckSecret_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// ChatServiceServer is the server API for ChatService service.
|
|
// All implementations must embed UnimplementedChatServiceServer
|
|
// for forward compatibility.
|
|
type ChatServiceServer interface {
|
|
RecentLogs(context.Context, *RecentLogsRequest) (*RecentLogsResponse, error)
|
|
Snapshot(context.Context, *SnapshotRequest) (*SnapshotResponse, error)
|
|
GetSession(context.Context, *GetSessionRequest) (*GetSessionResponse, error)
|
|
RecentMessages(context.Context, *RecentMessagesRequest) (*RecentMessagesResponse, error)
|
|
RecentTurns(context.Context, *RecentTurnsRequest) (*RecentTurnsResponse, error)
|
|
Route(context.Context, *RouteRequest) (*RouteResponse, error)
|
|
Stream(*StreamRequest, grpc.ServerStreamingServer[StreamResponse]) error
|
|
Answer(context.Context, *AnswerRequest) (*AnswerResponse, error)
|
|
Cancel(context.Context, *CancelRequest) (*CancelResponse, error)
|
|
StopTasks(context.Context, *StopTasksRequest) (*StopTasksResponse, error)
|
|
ApplyTaskAction(context.Context, *ApplyTaskActionRequest) (*ApplyTaskActionResponse, error)
|
|
ApplyOperatorTaskAction(context.Context, *ApplyOperatorTaskActionRequest) (*ApplyOperatorTaskActionResponse, error)
|
|
SaveSession(context.Context, *SaveSessionRequest) (*SaveSessionResponse, error)
|
|
GetSessionsByChannel(context.Context, *GetSessionsByChannelRequest) (*GetSessionsByChannelResponse, error)
|
|
DeleteSession(context.Context, *DeleteSessionRequest) (*DeleteSessionResponse, error)
|
|
TouchSession(context.Context, *TouchSessionRequest) (*TouchSessionResponse, error)
|
|
ListSessions(context.Context, *ListSessionsRequest) (*ListSessionsResponse, error)
|
|
SaveMessage(context.Context, *SaveMessageRequest) (*SaveMessageResponse, error)
|
|
DeleteRecentMessages(context.Context, *DeleteRecentMessagesRequest) (*DeleteRecentMessagesResponse, error)
|
|
MessageCount(context.Context, *MessageCountRequest) (*MessageCountResponse, error)
|
|
SaveMessages(context.Context, *SaveMessagesRequest) (*SaveMessagesResponse, error)
|
|
ReplaceMessages(context.Context, *ReplaceMessagesRequest) (*ReplaceMessagesResponse, error)
|
|
SearchMessages(context.Context, *SearchMessagesRequest) (*SearchMessagesResponse, error)
|
|
ListSkills(context.Context, *ListSkillsRequest) (*ListSkillsResponse, error)
|
|
CuratorHealth(context.Context, *CuratorHealthRequest) (*CuratorHealthResponse, error)
|
|
ReloadChannel(context.Context, *ReloadChannelRequest) (*ReloadChannelResponse, error)
|
|
// CheckSecret reports resolution in this process without returning a value.
|
|
CheckSecret(context.Context, *CheckSecretRequest) (*CheckSecretResponse, error)
|
|
mustEmbedUnimplementedChatServiceServer()
|
|
}
|
|
|
|
// UnimplementedChatServiceServer must be embedded to have
|
|
// forward compatible implementations.
|
|
//
|
|
// NOTE: this should be embedded by value instead of pointer to avoid a nil
|
|
// pointer dereference when methods are called.
|
|
type UnimplementedChatServiceServer struct{}
|
|
|
|
func (UnimplementedChatServiceServer) RecentLogs(context.Context, *RecentLogsRequest) (*RecentLogsResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method RecentLogs not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) Snapshot(context.Context, *SnapshotRequest) (*SnapshotResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method Snapshot not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) GetSession(context.Context, *GetSessionRequest) (*GetSessionResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method GetSession not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) RecentMessages(context.Context, *RecentMessagesRequest) (*RecentMessagesResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method RecentMessages not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) RecentTurns(context.Context, *RecentTurnsRequest) (*RecentTurnsResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method RecentTurns not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) Route(context.Context, *RouteRequest) (*RouteResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method Route not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) Stream(*StreamRequest, grpc.ServerStreamingServer[StreamResponse]) error {
|
|
return status.Error(codes.Unimplemented, "method Stream not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) Answer(context.Context, *AnswerRequest) (*AnswerResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method Answer not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) Cancel(context.Context, *CancelRequest) (*CancelResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method Cancel not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) StopTasks(context.Context, *StopTasksRequest) (*StopTasksResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method StopTasks not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) ApplyTaskAction(context.Context, *ApplyTaskActionRequest) (*ApplyTaskActionResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ApplyTaskAction not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) ApplyOperatorTaskAction(context.Context, *ApplyOperatorTaskActionRequest) (*ApplyOperatorTaskActionResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ApplyOperatorTaskAction not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) SaveSession(context.Context, *SaveSessionRequest) (*SaveSessionResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SaveSession not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) GetSessionsByChannel(context.Context, *GetSessionsByChannelRequest) (*GetSessionsByChannelResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method GetSessionsByChannel not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) DeleteSession(context.Context, *DeleteSessionRequest) (*DeleteSessionResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method DeleteSession not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) TouchSession(context.Context, *TouchSessionRequest) (*TouchSessionResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method TouchSession not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) ListSessions(context.Context, *ListSessionsRequest) (*ListSessionsResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ListSessions not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) SaveMessage(context.Context, *SaveMessageRequest) (*SaveMessageResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SaveMessage not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) DeleteRecentMessages(context.Context, *DeleteRecentMessagesRequest) (*DeleteRecentMessagesResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method DeleteRecentMessages not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) MessageCount(context.Context, *MessageCountRequest) (*MessageCountResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method MessageCount not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) SaveMessages(context.Context, *SaveMessagesRequest) (*SaveMessagesResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SaveMessages not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) ReplaceMessages(context.Context, *ReplaceMessagesRequest) (*ReplaceMessagesResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ReplaceMessages not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) SearchMessages(context.Context, *SearchMessagesRequest) (*SearchMessagesResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SearchMessages not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) ListSkills(context.Context, *ListSkillsRequest) (*ListSkillsResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ListSkills not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) CuratorHealth(context.Context, *CuratorHealthRequest) (*CuratorHealthResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method CuratorHealth not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) ReloadChannel(context.Context, *ReloadChannelRequest) (*ReloadChannelResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method ReloadChannel not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) CheckSecret(context.Context, *CheckSecretRequest) (*CheckSecretResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method CheckSecret not implemented")
|
|
}
|
|
func (UnimplementedChatServiceServer) mustEmbedUnimplementedChatServiceServer() {}
|
|
func (UnimplementedChatServiceServer) testEmbeddedByValue() {}
|
|
|
|
// UnsafeChatServiceServer may be embedded to opt out of forward compatibility for this service.
|
|
// Use of this interface is not recommended, as added methods to ChatServiceServer will
|
|
// result in compilation errors.
|
|
type UnsafeChatServiceServer interface {
|
|
mustEmbedUnimplementedChatServiceServer()
|
|
}
|
|
|
|
func RegisterChatServiceServer(s grpc.ServiceRegistrar, srv ChatServiceServer) {
|
|
// If the following call panics, it indicates UnimplementedChatServiceServer was
|
|
// embedded by pointer and is nil. This will cause panics if an
|
|
// unimplemented method is ever invoked, so we test this at initialization
|
|
// time to prevent it from happening at runtime later due to I/O.
|
|
if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
|
|
t.testEmbeddedByValue()
|
|
}
|
|
s.RegisterService(&ChatService_ServiceDesc, srv)
|
|
}
|
|
|
|
func _ChatService_RecentLogs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(RecentLogsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).RecentLogs(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_RecentLogs_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).RecentLogs(ctx, req.(*RecentLogsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_Snapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SnapshotRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).Snapshot(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_Snapshot_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).Snapshot(ctx, req.(*SnapshotRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_GetSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(GetSessionRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).GetSession(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_GetSession_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).GetSession(ctx, req.(*GetSessionRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_RecentMessages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(RecentMessagesRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).RecentMessages(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_RecentMessages_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).RecentMessages(ctx, req.(*RecentMessagesRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_RecentTurns_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(RecentTurnsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).RecentTurns(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_RecentTurns_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).RecentTurns(ctx, req.(*RecentTurnsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_Route_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(RouteRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).Route(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_Route_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).Route(ctx, req.(*RouteRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_Stream_Handler(srv interface{}, stream grpc.ServerStream) error {
|
|
m := new(StreamRequest)
|
|
if err := stream.RecvMsg(m); err != nil {
|
|
return err
|
|
}
|
|
return srv.(ChatServiceServer).Stream(m, &grpc.GenericServerStream[StreamRequest, StreamResponse]{ServerStream: stream})
|
|
}
|
|
|
|
// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
|
|
type ChatService_StreamServer = grpc.ServerStreamingServer[StreamResponse]
|
|
|
|
func _ChatService_Answer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(AnswerRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).Answer(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_Answer_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).Answer(ctx, req.(*AnswerRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_Cancel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CancelRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).Cancel(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_Cancel_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).Cancel(ctx, req.(*CancelRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_StopTasks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(StopTasksRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).StopTasks(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_StopTasks_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).StopTasks(ctx, req.(*StopTasksRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_ApplyTaskAction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ApplyTaskActionRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).ApplyTaskAction(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_ApplyTaskAction_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).ApplyTaskAction(ctx, req.(*ApplyTaskActionRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_ApplyOperatorTaskAction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ApplyOperatorTaskActionRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).ApplyOperatorTaskAction(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_ApplyOperatorTaskAction_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).ApplyOperatorTaskAction(ctx, req.(*ApplyOperatorTaskActionRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_SaveSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SaveSessionRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).SaveSession(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_SaveSession_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).SaveSession(ctx, req.(*SaveSessionRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_GetSessionsByChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(GetSessionsByChannelRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).GetSessionsByChannel(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_GetSessionsByChannel_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).GetSessionsByChannel(ctx, req.(*GetSessionsByChannelRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_DeleteSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(DeleteSessionRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).DeleteSession(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_DeleteSession_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).DeleteSession(ctx, req.(*DeleteSessionRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_TouchSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(TouchSessionRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).TouchSession(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_TouchSession_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).TouchSession(ctx, req.(*TouchSessionRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_ListSessions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ListSessionsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).ListSessions(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_ListSessions_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).ListSessions(ctx, req.(*ListSessionsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_SaveMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SaveMessageRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).SaveMessage(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_SaveMessage_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).SaveMessage(ctx, req.(*SaveMessageRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_DeleteRecentMessages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(DeleteRecentMessagesRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).DeleteRecentMessages(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_DeleteRecentMessages_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).DeleteRecentMessages(ctx, req.(*DeleteRecentMessagesRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_MessageCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(MessageCountRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).MessageCount(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_MessageCount_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).MessageCount(ctx, req.(*MessageCountRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_SaveMessages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SaveMessagesRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).SaveMessages(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_SaveMessages_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).SaveMessages(ctx, req.(*SaveMessagesRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_ReplaceMessages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ReplaceMessagesRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).ReplaceMessages(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_ReplaceMessages_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).ReplaceMessages(ctx, req.(*ReplaceMessagesRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_SearchMessages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SearchMessagesRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).SearchMessages(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_SearchMessages_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).SearchMessages(ctx, req.(*SearchMessagesRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_ListSkills_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ListSkillsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).ListSkills(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_ListSkills_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).ListSkills(ctx, req.(*ListSkillsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_CuratorHealth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CuratorHealthRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).CuratorHealth(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_CuratorHealth_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).CuratorHealth(ctx, req.(*CuratorHealthRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_ReloadChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(ReloadChannelRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).ReloadChannel(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_ReloadChannel_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).ReloadChannel(ctx, req.(*ReloadChannelRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _ChatService_CheckSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CheckSecretRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(ChatServiceServer).CheckSecret(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: ChatService_CheckSecret_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(ChatServiceServer).CheckSecret(ctx, req.(*CheckSecretRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
// ChatService_ServiceDesc is the grpc.ServiceDesc for ChatService service.
|
|
// It's only intended for direct use with grpc.RegisterService,
|
|
// and not to be introspected or modified (even as a copy)
|
|
var ChatService_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "gateway.v1.ChatService",
|
|
HandlerType: (*ChatServiceServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "RecentLogs",
|
|
Handler: _ChatService_RecentLogs_Handler,
|
|
},
|
|
{
|
|
MethodName: "Snapshot",
|
|
Handler: _ChatService_Snapshot_Handler,
|
|
},
|
|
{
|
|
MethodName: "GetSession",
|
|
Handler: _ChatService_GetSession_Handler,
|
|
},
|
|
{
|
|
MethodName: "RecentMessages",
|
|
Handler: _ChatService_RecentMessages_Handler,
|
|
},
|
|
{
|
|
MethodName: "RecentTurns",
|
|
Handler: _ChatService_RecentTurns_Handler,
|
|
},
|
|
{
|
|
MethodName: "Route",
|
|
Handler: _ChatService_Route_Handler,
|
|
},
|
|
{
|
|
MethodName: "Answer",
|
|
Handler: _ChatService_Answer_Handler,
|
|
},
|
|
{
|
|
MethodName: "Cancel",
|
|
Handler: _ChatService_Cancel_Handler,
|
|
},
|
|
{
|
|
MethodName: "StopTasks",
|
|
Handler: _ChatService_StopTasks_Handler,
|
|
},
|
|
{
|
|
MethodName: "ApplyTaskAction",
|
|
Handler: _ChatService_ApplyTaskAction_Handler,
|
|
},
|
|
{
|
|
MethodName: "ApplyOperatorTaskAction",
|
|
Handler: _ChatService_ApplyOperatorTaskAction_Handler,
|
|
},
|
|
{
|
|
MethodName: "SaveSession",
|
|
Handler: _ChatService_SaveSession_Handler,
|
|
},
|
|
{
|
|
MethodName: "GetSessionsByChannel",
|
|
Handler: _ChatService_GetSessionsByChannel_Handler,
|
|
},
|
|
{
|
|
MethodName: "DeleteSession",
|
|
Handler: _ChatService_DeleteSession_Handler,
|
|
},
|
|
{
|
|
MethodName: "TouchSession",
|
|
Handler: _ChatService_TouchSession_Handler,
|
|
},
|
|
{
|
|
MethodName: "ListSessions",
|
|
Handler: _ChatService_ListSessions_Handler,
|
|
},
|
|
{
|
|
MethodName: "SaveMessage",
|
|
Handler: _ChatService_SaveMessage_Handler,
|
|
},
|
|
{
|
|
MethodName: "DeleteRecentMessages",
|
|
Handler: _ChatService_DeleteRecentMessages_Handler,
|
|
},
|
|
{
|
|
MethodName: "MessageCount",
|
|
Handler: _ChatService_MessageCount_Handler,
|
|
},
|
|
{
|
|
MethodName: "SaveMessages",
|
|
Handler: _ChatService_SaveMessages_Handler,
|
|
},
|
|
{
|
|
MethodName: "ReplaceMessages",
|
|
Handler: _ChatService_ReplaceMessages_Handler,
|
|
},
|
|
{
|
|
MethodName: "SearchMessages",
|
|
Handler: _ChatService_SearchMessages_Handler,
|
|
},
|
|
{
|
|
MethodName: "ListSkills",
|
|
Handler: _ChatService_ListSkills_Handler,
|
|
},
|
|
{
|
|
MethodName: "CuratorHealth",
|
|
Handler: _ChatService_CuratorHealth_Handler,
|
|
},
|
|
{
|
|
MethodName: "ReloadChannel",
|
|
Handler: _ChatService_ReloadChannel_Handler,
|
|
},
|
|
{
|
|
MethodName: "CheckSecret",
|
|
Handler: _ChatService_CheckSecret_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{
|
|
{
|
|
StreamName: "Stream",
|
|
Handler: _ChatService_Stream_Handler,
|
|
ServerStreams: true,
|
|
},
|
|
},
|
|
Metadata: "gateway/v1/chat.proto",
|
|
}
|