schedule

type APIFlavor interface {
	Name() string
	InstallRoutes(server *gin.Engine)

	// GetStreamResponseProlog In stream mode, some flavor may ask for some packets to be send first
	// or at the end, in addition to normal contents. For example, OpenAI
	// needs to send an additional "data: [DONE]" after everything is done.
	GetStreamResponseProlog(service string) []string
	GetStreamResponseEpilog(service string) []string

	// Convert This should cover the 6 conversion methods below
	Convert(service string, conversion string, content types.HTTPContent, ctx convert.ConvertContext) (types.HTTPContent, error)

	ConvertRequestToAOG(service string, content types.HTTPContent, ctx convert.ConvertContext) (types.HTTPContent, error)
	ConvertRequestFromAOG(service string, content types.HTTPContent, ctx convert.ConvertContext) (types.HTTPContent, error)
	ConvertResponseToAOG(service string, content types.HTTPContent, ctx convert.ConvertContext) (types.HTTPContent, error)
	ConvertResponseFromAOG(service string, content types.HTTPContent, ctx convert.ConvertContext) (types.HTTPContent, error)
	ConvertStreamResponseToAOG(service string, content types.HTTPContent, ctx convert.ConvertContext) (types.HTTPContent, error)
	ConvertStreamResponseFromAOG(service string, content types.HTTPContent, ctx convert.ConvertContext) (types.HTTPContent, error)
}

type APIKEYAuthenticator struct {
	AuthInfo string `json:"auth_info"`
	Req      http.Request
}

type ApiKeyAuthInfo struct {
	ApiKey string `json:"api_key"`
}

type Authenticator interface {
	Authenticate() error
}

type AuthenticatorParams struct {
	Request      *http.Request
	ProviderInfo *types.ServiceProvider
	RequestBody  string
}

type BaseGRPCHandler struct{}

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

type BaseMiddleware struct {
	ServiceName string
}

type BasicServiceScheduler struct {
	WaitingList *utils.SafeList
	RunningList *utils.SafeList
	ChEvent     chan *ServiceTaskEvent
	// contains filtered or unexported fields
}

type ChatMiddleware struct {
	BaseMiddleware
}

type ConfigBasedAPIFlavor struct {
	Config FlavorDef
	// contains filtered or unexported fields
}

type DefaultMetricsCollector struct{}

type Event struct {
	Header  Header  `json:"header"`
	Payload Payload `json:"payload"`
}

type FlavorDef struct {
	Version  string                      `yaml:"version"`
	Name     string                      `yaml:"name"`
	Services map[string]FlavorServiceDef `yaml:"services"`
}

type FlavorServiceDef struct {
	Protocol              string                    `yaml:"protocol"`
	ExposeProtocol        string                    `yaml:"expose_protocol"`
	TaskType              string                    `yaml:"task_type"`
	Endpoints             []string                  `yaml:"endpoints"`
	InstallRawRoutes      bool                      `yaml:"install_raw_routes"`
	DefaultModel          string                    `yaml:"default_model"`
	RequestUrl            string                    `yaml:"url"`
	RequestExtraUrl       string                    `yaml:"extra_url"`
	AuthType              string                    `yaml:"auth_type"`
	AuthApplyUrl          string                    `yaml:"auth_apply_url"`
	RequestSegments       int                       `yaml:"request_segments"`
	ExtraHeaders          string                    `yaml:"extra_headers"`
	SupportModels         []string                  `yaml:"support_models"`
	ModelSelector         ModelSelector             `yaml:"model_selector"`
	RequestToAOG          types.FlavorConversionDef `yaml:"request_to_aog"`
	RequestFromAOG        types.FlavorConversionDef `yaml:"request_from_aog"`
	ResponseToAOG         types.FlavorConversionDef `yaml:"response_to_aog"`
	ResponseFromAOG       types.FlavorConversionDef `yaml:"response_from_aog"`
	StreamResponseToAOG   types.FlavorConversionDef `yaml:"stream_response_to_aog"`
	StreamResponseFromAOG types.FlavorConversionDef `yaml:"stream_response_from_aog"`
}

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

type GRPCServiceHandler interface {
	PrepareRequest(content types.HTTPContent, target *types.ServiceTarget) (*grpc_client.ModelInferRequest, error)
	ProcessResponse(inferResponse *grpc_client.ModelInferResponse) (*http.Response, error)

	PrepareStreamRequest(content types.HTTPContent, st *ServiceTask) (*grpc_client.ModelInferRequest, error)
	ProcessStreamResponse(streamResponse *grpc_client.ModelStreamInferResponse, wsConnID string) (*http.Response, bool, error)
}

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

type HandlerMetrics struct {
	StartTime   time.Time
	Duration    time.Duration
	HandlerName string
}

type Header struct {
	Action       string                 `json:"action"`
	TaskID       string                 `json:"task_id"`
	Streaming    string                 `json:"streaming"`
	Event        string                 `json:"event"`
	ErrorCode    string                 `json:"error_code,omitempty"`
	ErrorMessage string                 `json:"error_message,omitempty"`
	Attributes   map[string]interface{} `json:"attributes"`
}

type ImageToImageMiddleware struct {
	BaseMiddleware
}

type ImageToVideoMiddleware struct {
	BaseMiddleware
}

type Input struct{}

type Invoker interface {
	Invoke(sp *types.ServiceProvider, content types.HTTPContent) (*http.Response, error)
}

type MetricsCollector interface {
	CollectMetrics(metrics HandlerMetrics)
}

type MiddlewareHandler struct {
	BaseHandler
}

type ModelSelector struct {
	ModelInRequest  string `yaml:"request"`
	ModelInResponse string `yaml:"response"`
}

type Output struct {
	Sentence struct {
		BeginTime int64  `json:"begin_time"`
		EndTime   *int64 `json:"end_time"`
		Text      string `json:"text"`
		Words     []struct {
			BeginTime   int64  `json:"begin_time"`
			EndTime     *int64 `json:"end_time"`
			Text        string `json:"text"`
			Punctuation string `json:"punctuation"`
		} `json:"words"`
	} `json:"sentence"`
	Usage interface{} `json:"usage"`
}

type Params struct {
	Format                   string   `json:"format"`
	SampleRate               int      `json:"sample_rate"`
	VocabularyID             string   `json:"vocabulary_id"`
	DisfluencyRemovalEnabled bool     `json:"disfluency_removal_enabled"`
	LanguageHints            []string `json:"language_hints"`
}

type Payload struct {
	TaskGroup  string `json:"task_group"`
	Task       string `json:"task"`
	Function   string `json:"function"`
	Model      string `json:"model"`
	Parameters Params `json:"parameters"`
	// Resources  []Resource `json:"resources"`
	Input  Input  `json:"input"`
	Output Output `json:"output,omitempty"`
}

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

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

type RequestConversionHandler struct {
	BaseHandler
}

type ResponseHandler struct {
	BaseHandler
}

type RetryableError struct {
	Err error
}

type ServiceContext struct {
	Task       *ServiceTask
	Request    *types.HTTPContent
	Response   *http.Response
	Error      error
	Metrics    MetricsCollector
	RetryCount int
	MaxRetries int
}

type ServiceDefaultInfo struct {
	Endpoints       []string `json:"endpoints"`
	DefaultModel    string   `json:"default_model"`
	RequestUrl      string   `json:"url"`
	RequestExtraUrl string   `json:"request_extra_url"`
	AuthType        string   `json:"auth_type"`
	RequestSegments int      `json:"request_segments"`
	ExtraHeaders    string   `json:"extra_headers"`
	SupportModels   []string `json:"support_models"`
	AuthApplyUrl    string   `json:"auth_apply_url"`
	Protocol        string   `json:"protocol"`
	TaskType        string   `json:"task_type"`
	ExposeProtocol  string   `json:"expose_protocol"`
}

type ServiceHandler interface {
	Handle(ctx *ServiceContext) error
}

type ServiceInvokerHandler struct {
	BaseHandler
}

type ServiceScheduler interface {
	// Enqueue itself is a non-blocking API. It returns the task ID and
	// a chan to return results as the Restful service
	Enqueue(*types.ServiceRequest) (uint64, chan *types.ServiceResult)
	Start()
	TaskComplete(*ServiceTask, error)
}

type ServiceTask struct {
	Request  *types.ServiceRequest
	Target   *types.ServiceTarget
	Ch       chan *types.ServiceResult
	Error    error
	Schedule types.ScheduleDetails
}

type ServiceTaskEvent struct {
	Type  ServiceTaskEventType
	Task  *ServiceTask
	Error error // only for ServiceTaskFailed
}

type ServiceTaskEventType int

type SignAuthInfo struct {
	SecretId  string `json:"secret_id"`
	SecretKey string `json:"secret_key"`
}

type SignCommonParams struct {
	Version string `json:"version"`
	Action  string `json:"action"`
	Region  string `json:"region"`
}

type SignParams struct {
	SecretId      string           `json:"secret_id"`
	SecretKey     string           `json:"secret_key"`
	RequestBody   string           `json:"request_body"`
	RequestUrl    string           `json:"request_url"`
	RequestMethod string           `json:"request_method"`
	RequestHeader http.Header      `json:"request_header"`
	CommonParams  SignCommonParams `json:"common_params"`
}

type SpeechToTextHandler struct {
	BaseGRPCHandler
}

type SpeechToTextMiddleware struct {
	BaseMiddleware
}

type SpeechToTextWSHandler struct {
	BaseGRPCHandler
}

type SpeechToTextWSMiddleware struct {
	BaseMiddleware
}

type SpeechToTextWSRemoteHandler struct {
	BaseGRPCHandler
}

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

type TaskMiddleware interface {
	Handle(st *ServiceTask) error
}

type TencentSignAuthenticator struct {
	AuthInfo     string                `json:"auth_info"`
	Req          http.Request          `json:"request"`
	ProviderInfo types.ServiceProvider `json:"provider_info"`
	ReqBody      string                `json:"req_body"`
}

type TextToImageHandler struct {
	BaseGRPCHandler
}

type TextToImageMiddleware struct {
	BaseMiddleware
}

type TextToSpeechHandler struct {
	BaseGRPCHandler
}

type TextToSpeechMiddleware struct {
	BaseMiddleware
}